--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2009/11/17 14:45:32	1.34
+++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2011/05/02 00:49:26	1.53
@@ -1,7 +1,7 @@
 /*
  * 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
+ * http://creativecommons.org/publicdomain/zero/1.0/
  * Other contributors include Andrew Wright, Jeffrey Hayes,
  * Pat Fisher, Mike Judd.
  */
@@ -9,15 +9,16 @@
 import junit.framework.*;
 import java.util.concurrent.locks.*;
 import java.util.concurrent.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import java.io.*;
 import java.util.*;
 
 public class ReentrantReadWriteLockTest extends JSR166TestCase {
     public static void main(String[] args) {
-	junit.textui.TestRunner.run (suite());
+        junit.textui.TestRunner.run(suite());
     }
     public static Test suite() {
-	return new TestSuite(ReentrantReadWriteLockTest.class);
+        return new TestSuite(ReentrantReadWriteLockTest.class);
     }
 
     /**
@@ -58,18 +59,27 @@ public class ReentrantReadWriteLockTest
     }
 
     /**
+     * Releases lock, checking that it had a hold count of 1.
+     */
+    void releaseLock(ReentrantReadWriteLock.WriteLock lock) {
+        assertTrue(lock.isHeldByCurrentThread());
+        lock.unlock();
+        assertFalse(lock.isHeldByCurrentThread());
+    }
+
+    /**
      * Constructor sets given fairness, and is in unlocked state
      */
     public void testConstructor() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
         assertFalse(rl.isFair());
         assertFalse(rl.isWriteLocked());
         assertEquals(0, rl.getReadLockCount());
-	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
+        ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
         assertTrue(r2.isFair());
         assertFalse(r2.isWriteLocked());
         assertEquals(0, r2.getReadLockCount());
-	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
+        ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
         assertFalse(r3.isFair());
         assertFalse(r3.isWriteLocked());
         assertEquals(0, r3.getReadLockCount());
@@ -79,7 +89,7 @@ public class ReentrantReadWriteLockTest
      * write-locking and read-locking an unlocked lock succeed
      */
     public void testLock() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
         rl.writeLock().lock();
         assertTrue(rl.isWriteLocked());
         assertTrue(rl.isWriteLockedByCurrentThread());
@@ -105,7 +115,7 @@ public class ReentrantReadWriteLockTest
      * locking an unlocked fair lock succeeds
      */
     public void testFairLock() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
         rl.writeLock().lock();
         assertTrue(rl.isWriteLocked());
         assertTrue(rl.isWriteLockedByCurrentThread());
@@ -130,45 +140,45 @@ public class ReentrantReadWriteLockTest
      * 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());
-	}
+        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();
-	    assertEquals(i,lock.writeLock().getHoldCount());
-	}
-	for (int i = SIZE; i > 0; i--) {
-	    lock.writeLock().unlock();
-	    assertEquals(i-1,lock.writeLock().getHoldCount());
-	}
+        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        for (int i = 1; i <= SIZE; i++) {
+            lock.writeLock().lock();
+            assertEquals(i,lock.writeLock().getHoldCount());
+        }
+        for (int i = SIZE; i > 0; i--) {
+            lock.writeLock().unlock();
+            assertEquals(i-1,lock.writeLock().getHoldCount());
+        }
     }
 
     /**
      * getReadHoldCount returns number of recursive holds
      */
     public void testGetReadHoldCount() {
-	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	for (int i = 1; i <= SIZE; i++) {
-	    lock.readLock().lock();
-	    assertEquals(i,lock.getReadHoldCount());
-	}
-	for (int i = SIZE; i > 0; i--) {
-	    lock.readLock().unlock();
-	    assertEquals(i-1,lock.getReadHoldCount());
-	}
+        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        for (int i = 1; i <= SIZE; i++) {
+            lock.readLock().lock();
+            assertEquals(i,lock.getReadHoldCount());
+        }
+        for (int i = SIZE; i > 0; i--) {
+            lock.readLock().unlock();
+            assertEquals(i-1,lock.getReadHoldCount());
+        }
     }
 
 
@@ -176,11 +186,11 @@ public class ReentrantReadWriteLockTest
      * write-unlocking an unlocked lock throws IllegalMonitorStateException
      */
     public void testUnlock_IllegalMonitorStateException() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
-	try {
-	    rl.writeLock().unlock();
-	    shouldThrow();
-	} catch (IllegalMonitorStateException success) {}
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+        try {
+            rl.writeLock().unlock();
+            shouldThrow();
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
@@ -188,74 +198,68 @@ public class ReentrantReadWriteLockTest
      * write-lockInterruptibly is interruptible
      */
     public void testWriteLockInterruptibly_Interrupted() throws Exception {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lockInterruptibly();
-                lock.writeLock().unlock();
-                lock.writeLock().lockInterruptibly();
-                lock.writeLock().unlock();
             }});
 
-        lock.writeLock().lock();
-        t.start();
         Thread.sleep(SHORT_DELAY_MS);
         t.interrupt();
-        Thread.sleep(SHORT_DELAY_MS);
-        lock.writeLock().unlock();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
+        releaseLock(lock.writeLock());
     }
 
     /**
      * timed write-tryLock is interruptible
      */
     public void testWriteTryLock_Interrupted() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
-                lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
+                lock.writeLock().tryLock(SMALL_DELAY_MS, MILLISECONDS);
             }});
 
-        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
         t.interrupt();
-        lock.writeLock().unlock();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
+        releaseLock(lock.writeLock());
     }
 
     /**
      * read-lockInterruptibly is interruptible
      */
     public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.readLock().lockInterruptibly();
             }});
 
-        t.start();
         Thread.sleep(SHORT_DELAY_MS);
         t.interrupt();
-        Thread.sleep(SHORT_DELAY_MS);
-        lock.writeLock().unlock();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
+        releaseLock(lock.writeLock());
     }
 
     /**
      * timed read-tryLock is interruptible
      */
     public void testReadTryLock_Interrupted() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
-                lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
+                lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
             }});
 
-        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
         t.interrupt();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
+        releaseLock(lock.writeLock());
     }
 
 
@@ -263,16 +267,14 @@ public class ReentrantReadWriteLockTest
      * write-tryLock fails if locked
      */
     public void testWriteTryLockWhenLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new Runnable() {
-                public void run() {
-                    threadAssertFalse(lock.writeLock().tryLock());
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                assertFalse(lock.writeLock().tryLock());
+            }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         lock.writeLock().unlock();
     }
 
@@ -280,16 +282,14 @@ public class ReentrantReadWriteLockTest
      * read-tryLock fails if locked
      */
     public void testReadTryLockWhenLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new Runnable() {
-                public void run() {
-                    threadAssertFalse(lock.readLock().tryLock());
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                assertFalse(lock.readLock().tryLock());
+            }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         lock.writeLock().unlock();
     }
 
@@ -297,17 +297,15 @@ public class ReentrantReadWriteLockTest
      * Multiple threads can hold a read lock when not write-locked
      */
     public void testMultipleReadLocks() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
-                public void run() {
-                    threadAssertTrue(lock.readLock().tryLock());
-                    lock.readLock().unlock();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                assertTrue(lock.readLock().tryLock());
+                lock.readLock().unlock();
+            }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         lock.readLock().unlock();
     }
 
@@ -315,66 +313,54 @@ public class ReentrantReadWriteLockTest
      * A writelock succeeds after reading threads unlock
      */
     public void testWriteAfterMultipleReadLocks() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.readLock().lock();
+                lock.readLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**
      * Readlocks succeed after a writing thread unlocks
      */
     public void testReadAfterWriteLock() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.readLock().lock();
+                lock.readLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.readLock().lock();
+                lock.readLock().unlock();
+            }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**
      * Read trylock succeeds if write locked by current thread
      */
     public void testReadHoldingWriteLock() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
         assertTrue(lock.readLock().tryLock());
         lock.readLock().unlock();
         lock.writeLock().unlock();
@@ -385,102 +371,84 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for readlock
      */
     public void testReadHoldingWriteLock2() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.readLock().lock();
+                lock.readLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.readLock().lock();
+                lock.readLock().unlock();
+            }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**
-     *  Read lock succeeds if write locked by current thread even if
+     * Read lock succeeds if write locked by current thread even if
      * other threads are waiting for writelock
      */
     public void testReadHoldingWriteLock3() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
 
     /**
-     *  Write lock succeeds if write locked by current thread even if
+     * Write lock succeeds if write locked by current thread even if
      * other threads are waiting for writelock
      */
     public void testWriteHoldingWriteLock4() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
 
@@ -488,8 +456,8 @@ public class ReentrantReadWriteLockTest
      * Fair Read trylock succeeds if write locked by current thread
      */
     public void testReadHoldingWriteLockFair() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.writeLock().lock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
         assertTrue(lock.readLock().tryLock());
         lock.readLock().unlock();
         lock.writeLock().unlock();
@@ -500,33 +468,27 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for readlock
      */
     public void testReadHoldingWriteLockFair2() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.readLock().lock();
+                lock.readLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.readLock().lock();
+                lock.readLock().unlock();
+            }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
 
@@ -535,33 +497,27 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for writelock
      */
     public void testReadHoldingWriteLockFair3() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
 
@@ -570,36 +526,30 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for writelock
      */
     public void testWriteHoldingWriteLockFair4() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
+        Thread t1 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                lock.writeLock().lock();
+                lock.writeLock().unlock();
+            }});
 
-        t1.start();
-        t2.start();
         Thread.sleep(SHORT_DELAY_MS);
         assertTrue(lock.isWriteLockedByCurrentThread());
-        assertTrue(lock.getWriteHoldCount() == 1);
+        assertEquals(1, lock.getWriteHoldCount());
         lock.writeLock().lock();
-        assertTrue(lock.getWriteHoldCount() == 2);
+        assertEquals(2, lock.getWriteHoldCount());
         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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
 
@@ -607,36 +557,30 @@ public class ReentrantReadWriteLockTest
      * Read tryLock succeeds if readlocked but not writelocked
      */
     public void testTryLockWhenReadLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
-                public void run() {
-                    threadAssertTrue(lock.readLock().tryLock());
-                    lock.readLock().unlock();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                assertTrue(lock.readLock().tryLock());
+                lock.readLock().unlock();
+            }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         lock.readLock().unlock();
     }
 
-
-
     /**
      * write tryLock fails when readlocked
      */
     public void testWriteTryLockWhenReadLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
-                public void run() {
-                    threadAssertFalse(lock.writeLock().tryLock());
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                assertFalse(lock.writeLock().tryLock());
+            }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         lock.readLock().unlock();
     }
 
@@ -645,17 +589,15 @@ public class ReentrantReadWriteLockTest
      * Fair Read tryLock succeeds if readlocked but not writelocked
      */
     public void testTryLockWhenReadLockedFair() throws InterruptedException {
-	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();
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.readLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                assertTrue(lock.readLock().tryLock());
+                lock.readLock().unlock();
+            }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         lock.readLock().unlock();
     }
 
@@ -665,16 +607,14 @@ public class ReentrantReadWriteLockTest
      * Fair write tryLock fails when readlocked
      */
     public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
-                public void run() {
-                    threadAssertFalse(lock.writeLock().tryLock());
-		}
-	    });
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.readLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                assertFalse(lock.writeLock().tryLock());
+            }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         lock.readLock().unlock();
     }
 
@@ -684,15 +624,14 @@ public class ReentrantReadWriteLockTest
      * write timed tryLock times out if locked
      */
     public void testWriteTryLock_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
+                assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
             }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         assertTrue(lock.writeLock().isHeldByCurrentThread());
         lock.writeLock().unlock();
     }
@@ -701,15 +640,14 @@ public class ReentrantReadWriteLockTest
      * read timed tryLock times out if write-locked
      */
     public void testReadTryLock_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
+                assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
             }});
 
-        t.start();
-        t.join();
+        awaitTermination(t, LONG_DELAY_MS);
         assertTrue(lock.writeLock().isHeldByCurrentThread());
         lock.writeLock().unlock();
     }
@@ -719,44 +657,41 @@ public class ReentrantReadWriteLockTest
      * write lockInterruptibly succeeds if lock free else is interruptible
      */
     public void testWriteLockInterruptibly() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         lock.writeLock().lockInterruptibly();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lockInterruptibly();
             }});
 
-        t.start();
         Thread.sleep(SHORT_DELAY_MS);
         t.interrupt();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.join();
-        lock.writeLock().unlock();
+        awaitTermination(t, LONG_DELAY_MS);
+        releaseLock(lock.writeLock());
     }
 
     /**
-     *  read lockInterruptibly succeeds if lock free else is interruptible
+     * read lockInterruptibly succeeds if lock free else is interruptible
      */
     public void testReadLockInterruptibly() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         lock.writeLock().lockInterruptibly();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.readLock().lockInterruptibly();
             }});
 
-        t.start();
         Thread.sleep(SHORT_DELAY_MS);
         t.interrupt();
-        t.join();
-        lock.writeLock().unlock();
+        awaitTermination(t, LONG_DELAY_MS);
+        releaseLock(lock.writeLock());
     }
 
     /**
      * Calling await without holding lock throws IllegalMonitorStateException
      */
     public void testAwait_IllegalMonitor() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             c.await();
@@ -768,7 +703,7 @@ public class ReentrantReadWriteLockTest
      * Calling signal without holding lock throws IllegalMonitorStateException
      */
     public void testSignal_IllegalMonitor() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             c.signal();
@@ -780,7 +715,7 @@ public class ReentrantReadWriteLockTest
      * awaitNanos without a signal times out
      */
     public void testAwaitNanos_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
 
         lock.writeLock().lock();
@@ -791,13 +726,13 @@ public class ReentrantReadWriteLockTest
 
 
     /**
-     *  timed await without a signal times out
+     * timed await without a signal times out
      */
     public void testAwait_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         lock.writeLock().lock();
-        assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+        assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
         lock.writeLock().unlock();
     }
 
@@ -805,7 +740,7 @@ public class ReentrantReadWriteLockTest
      * awaitUntil without a signal times out
      */
     public void testAwaitUntil_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         lock.writeLock().lock();
         java.util.Date d = new java.util.Date();
@@ -817,22 +752,20 @@ public class ReentrantReadWriteLockTest
      * await returns when signalled
      */
     public void testAwait() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedRunnable() {
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.await();
                 lock.writeLock().unlock();
             }});
 
-        t.start();
         Thread.sleep(SHORT_DELAY_MS);
         lock.writeLock().lock();
         c.signal();
         lock.writeLock().unlock();
-        t.join(SHORT_DELAY_MS);
-        assertFalse(t.isAlive());
+        awaitTermination(t, LONG_DELAY_MS);
     }
 
     /** A helper class for uninterruptible wait tests */
@@ -885,102 +818,109 @@ public class ReentrantReadWriteLockTest
             lock.writeLock().unlock();
         }
 
-        thread.join();
+        awaitTermination(thread, LONG_DELAY_MS);
         assertTrue(thread.interrupted);
-        assertFalse(thread.isAlive());
     }
 
     /**
      * await is interruptible
      */
     public void testAwait_Interrupt() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final CountDownLatch locked = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
-                c.await();
-                lock.writeLock().unlock();
+                assertTrue(lock.isWriteLocked());
+                locked.countDown();
+                try { c.await(); }
+                finally { lock.writeLock().unlock(); }
             }});
 
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        locked.await();
+        while (lock.isWriteLocked())
+            Thread.yield();
         t.interrupt();
-        t.join(SHORT_DELAY_MS);
-        assertFalse(t.isAlive());
+        awaitTermination(t, LONG_DELAY_MS);
+        assertFalse(lock.isWriteLocked());
     }
 
     /**
      * awaitNanos is interruptible
      */
     public void testAwaitNanos_Interrupt() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final CountDownLatch locked = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
-                c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
-                lock.writeLock().unlock();
+                assertTrue(lock.isWriteLocked());
+                locked.countDown();
+                try { c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); }
+                finally { lock.writeLock().unlock(); }
             }});
 
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        locked.await();
+        while (lock.isWriteLocked())
+            Thread.yield();
         t.interrupt();
-        t.join(SHORT_DELAY_MS);
-        assertFalse(t.isAlive());
+        awaitTermination(t, LONG_DELAY_MS);
+        assertFalse(lock.isWriteLocked());
     }
 
     /**
      * awaitUntil is interruptible
      */
     public void testAwaitUntil_Interrupt() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final CountDownLatch locked = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
+                assertTrue(lock.isWriteLocked());
+                locked.countDown();
                 java.util.Date d = new java.util.Date();
-                c.awaitUntil(new java.util.Date(d.getTime() + 10000));
-                lock.writeLock().unlock();
+                try { c.awaitUntil(new java.util.Date(d.getTime() + 10000)); }
+                finally { lock.writeLock().unlock(); }
             }});
 
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        locked.await();
+        while (lock.isWriteLocked())
+            Thread.yield();
         t.interrupt();
-        t.join(SHORT_DELAY_MS);
-        assertFalse(t.isAlive());
+        awaitTermination(t, LONG_DELAY_MS);
+        assertFalse(lock.isWriteLocked());
     }
 
     /**
      * signalAll wakes up all threads
      */
     public void testSignalAll() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t1 = new Thread(new CheckedRunnable() {
+        Thread t1 = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.await();
                 lock.writeLock().unlock();
             }});
 
-	Thread t2 = new Thread(new CheckedRunnable() {
+        Thread t2 = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.await();
                 lock.writeLock().unlock();
             }});
 
-        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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**
@@ -1007,7 +947,7 @@ public class ReentrantReadWriteLockTest
      * hasQueuedThreads reports whether there are waiting threads
      */
     public void testhasQueuedThreads() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
         assertFalse(lock.hasQueuedThreads());
@@ -1024,15 +964,15 @@ public class ReentrantReadWriteLockTest
         lock.writeLock().unlock();
         Thread.sleep(SHORT_DELAY_MS);
         assertFalse(lock.hasQueuedThreads());
-        t1.join();
-        t2.join();
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**
      * hasQueuedThread(null) throws NPE
      */
     public void testHasQueuedThreadNPE() {
-	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
         try {
             sync.hasQueuedThread(null);
             shouldThrow();
@@ -1043,7 +983,7 @@ public class ReentrantReadWriteLockTest
      * hasQueuedThread reports whether a thread is queued.
      */
     public void testHasQueuedThread() throws InterruptedException {
-	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(sync));
         Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
         assertFalse(sync.hasQueuedThread(t1));
@@ -1065,8 +1005,8 @@ public class ReentrantReadWriteLockTest
         assertFalse(sync.hasQueuedThread(t1));
         Thread.sleep(SHORT_DELAY_MS);
         assertFalse(sync.hasQueuedThread(t2));
-        t1.join();
-        t2.join();
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
 
@@ -1074,7 +1014,7 @@ public class ReentrantReadWriteLockTest
      * getQueueLength reports number of waiting threads
      */
     public void testGetQueueLength() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
         assertEquals(0, lock.getQueueLength());
@@ -1091,15 +1031,15 @@ public class ReentrantReadWriteLockTest
         lock.writeLock().unlock();
         Thread.sleep(SHORT_DELAY_MS);
         assertEquals(0, lock.getQueueLength());
-        t1.join();
-        t2.join();
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**
      * getQueuedThreads includes waiting threads
      */
     public void testGetQueuedThreads() throws InterruptedException {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
         assertTrue(lock.getQueuedThreads().isEmpty());
@@ -1119,15 +1059,15 @@ public class ReentrantReadWriteLockTest
         lock.writeLock().unlock();
         Thread.sleep(SHORT_DELAY_MS);
         assertTrue(lock.getQueuedThreads().isEmpty());
-        t1.join();
-        t2.join();
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**
      * hasWaiters throws NPE if null
      */
     public void testHasWaitersNPE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         try {
             lock.hasWaiters(null);
             shouldThrow();
@@ -1138,7 +1078,7 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength throws NPE if null
      */
     public void testGetWaitQueueLengthNPE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         try {
             lock.getWaitQueueLength(null);
             shouldThrow();
@@ -1150,7 +1090,7 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads throws NPE if null
      */
     public void testGetWaitingThreadsNPE() {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         try {
             lock.getWaitingThreads(null);
             shouldThrow();
@@ -1161,9 +1101,9 @@ public class ReentrantReadWriteLockTest
      * hasWaiters throws IAE if not owned
      */
     public void testHasWaitersIAE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
         try {
             lock2.hasWaiters(c);
             shouldThrow();
@@ -1174,7 +1114,7 @@ public class ReentrantReadWriteLockTest
      * hasWaiters throws IMSE if not locked
      */
     public void testHasWaitersIMSE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             lock.hasWaiters(c);
@@ -1187,9 +1127,9 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength throws IAE if not owned
      */
     public void testGetWaitQueueLengthIAE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
         try {
             lock2.getWaitQueueLength(c);
             shouldThrow();
@@ -1200,7 +1140,7 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength throws IMSE if not locked
      */
     public void testGetWaitQueueLengthIMSE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             lock.getWaitQueueLength(c);
@@ -1213,9 +1153,9 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads throws IAE if not owned
      */
     public void testGetWaitingThreadsIAE() {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
         try {
             lock2.getWaitingThreads(c);
             shouldThrow();
@@ -1226,7 +1166,7 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads throws IMSE if not locked
      */
     public void testGetWaitingThreadsIMSE() {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             lock.getWaitingThreads(c);
@@ -1239,18 +1179,17 @@ public class ReentrantReadWriteLockTest
      * hasWaiters returns true when a thread is waiting, else false
      */
     public void testHasWaiters() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedRunnable() {
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
-                threadAssertFalse(lock.hasWaiters(c));
-                threadAssertEquals(0, lock.getWaitQueueLength(c));
+                assertFalse(lock.hasWaiters(c));
+                assertEquals(0, lock.getWaitQueueLength(c));
                 c.await();
                 lock.writeLock().unlock();
             }});
 
-        t.start();
         Thread.sleep(SHORT_DELAY_MS);
         lock.writeLock().lock();
         assertTrue(lock.hasWaiters(c));
@@ -1262,26 +1201,24 @@ public class ReentrantReadWriteLockTest
         assertFalse(lock.hasWaiters(c));
         assertEquals(0, lock.getWaitQueueLength(c));
         lock.writeLock().unlock();
-        t.join(SHORT_DELAY_MS);
-        assertFalse(t.isAlive());
+        awaitTermination(t, LONG_DELAY_MS);
     }
 
     /**
      * getWaitQueueLength returns number of waiting threads
      */
     public void testGetWaitQueueLength() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedRunnable() {
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
-                threadAssertFalse(lock.hasWaiters(c));
-                threadAssertEquals(0, lock.getWaitQueueLength(c));
+                assertFalse(lock.hasWaiters(c));
+                assertEquals(0, lock.getWaitQueueLength(c));
                 c.await();
                 lock.writeLock().unlock();
             }});
 
-        t.start();
         Thread.sleep(SHORT_DELAY_MS);
         lock.writeLock().lock();
         assertTrue(lock.hasWaiters(c));
@@ -1293,8 +1230,7 @@ public class ReentrantReadWriteLockTest
         assertFalse(lock.hasWaiters(c));
         assertEquals(0, lock.getWaitQueueLength(c));
         lock.writeLock().unlock();
-        t.join(SHORT_DELAY_MS);
-        assertFalse(t.isAlive());
+        awaitTermination(t, LONG_DELAY_MS);
     }
 
 
@@ -1302,20 +1238,20 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads returns only and all waiting threads
      */
     public void testGetWaitingThreads() throws InterruptedException {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t1 = new Thread(new CheckedRunnable() {
+        Thread t1 = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
-                threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
+                assertTrue(lock.getWaitingThreads(c).isEmpty());
                 c.await();
                 lock.writeLock().unlock();
             }});
 
-	Thread t2 = new Thread(new CheckedRunnable() {
+        Thread t2 = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
-                threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
+                assertFalse(lock.getWaitingThreads(c).isEmpty());
                 c.await();
                 lock.writeLock().unlock();
             }});
@@ -1338,10 +1274,8 @@ public class ReentrantReadWriteLockTest
         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());
+        awaitTermination(t1, LONG_DELAY_MS);
+        awaitTermination(t2, LONG_DELAY_MS);
     }
 
     /**