--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2009/11/16 04:57:10	1.29
+++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2009/11/17 14:45:32	1.34
@@ -23,13 +23,11 @@ public class ReentrantReadWriteLockTest
     /**
      * A runnable calling lockInterruptibly
      */
-    class InterruptibleLockRunnable implements Runnable {
+    class InterruptibleLockRunnable extends CheckedRunnable {
         final ReentrantReadWriteLock lock;
         InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
-        public void run() {
-            try {
-                lock.writeLock().lockInterruptibly();
-            } catch (InterruptedException success){}
+        public void realRun() throws InterruptedException {
+            lock.writeLock().lockInterruptibly();
         }
     }
 
@@ -38,14 +36,11 @@ public class ReentrantReadWriteLockTest
      * A runnable calling lockInterruptibly that expects to be
      * interrupted
      */
-    class InterruptedLockRunnable implements Runnable {
+    class InterruptedLockRunnable extends CheckedInterruptedRunnable {
         final ReentrantReadWriteLock lock;
         InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
-        public void run() {
-            try {
-                lock.writeLock().lockInterruptibly();
-                threadShouldThrow();
-            } catch (InterruptedException success){}
+        public void realRun() throws InterruptedException {
+            lock.writeLock().lockInterruptibly();
         }
     }
 
@@ -74,6 +69,10 @@ public class ReentrantReadWriteLockTest
         assertTrue(r2.isFair());
         assertFalse(r2.isWriteLocked());
         assertEquals(0, r2.getReadLockCount());
+	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
+        assertFalse(r3.isFair());
+        assertFalse(r3.isWriteLocked());
+        assertEquals(0, r3.getReadLockCount());
     }
 
     /**
@@ -181,114 +180,89 @@ public class ReentrantReadWriteLockTest
 	try {
 	    rl.writeLock().unlock();
 	    shouldThrow();
-	} catch (IllegalMonitorStateException success){}
+	} catch (IllegalMonitorStateException success) {}
     }
 
 
     /**
      * write-lockInterruptibly is interruptible
      */
-    public void testWriteLockInterruptibly_Interrupted() {
+    public void testWriteLockInterruptibly_Interrupted() throws Exception {
 	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();
-        }
+	Thread t = new Thread(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();
     }
 
     /**
      * timed write-tryLock is interruptible
      */
-    public void testWriteTryLock_Interrupted() {
+    public void testWriteTryLock_Interrupted() throws InterruptedException {
 	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();
-        }
+	Thread t = new Thread(new CheckedInterruptedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
+            }});
+
+        t.start();
+        t.interrupt();
+        lock.writeLock().unlock();
+        t.join();
     }
 
     /**
      * read-lockInterruptibly is interruptible
      */
-    public void testReadLockInterruptibly_Interrupted() {
+    public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
 	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();
-        }
+	Thread t = new Thread(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();
     }
 
     /**
      * timed read-tryLock is interruptible
      */
-    public void testReadTryLock_Interrupted() {
+    public void testReadTryLock_Interrupted() throws InterruptedException {
 	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();
-        }
+	Thread t = new Thread(new CheckedInterruptedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
+            }});
+
+        t.start();
+        t.interrupt();
+        t.join();
     }
 
 
     /**
      * write-tryLock fails if locked
      */
-    public void testWriteTryLockWhenLocked() {
+    public void testWriteTryLockWhenLocked() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.writeLock().lock();
 	Thread t = new Thread(new Runnable() {
@@ -296,19 +270,16 @@ public class ReentrantReadWriteLockTest
                     threadAssertFalse(lock.writeLock().tryLock());
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.writeLock().unlock();
-        } catch (Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.join();
+        lock.writeLock().unlock();
     }
 
     /**
      * read-tryLock fails if locked
      */
-    public void testReadTryLockWhenLocked() {
+    public void testReadTryLockWhenLocked() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.writeLock().lock();
 	Thread t = new Thread(new Runnable() {
@@ -316,19 +287,16 @@ public class ReentrantReadWriteLockTest
                     threadAssertFalse(lock.readLock().tryLock());
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.writeLock().unlock();
-        } catch (Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.join();
+        lock.writeLock().unlock();
     }
 
     /**
      * Multiple threads can hold a read lock when not write-locked
      */
-    public void testMultipleReadLocks() {
+    public void testMultipleReadLocks() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.readLock().lock();
 	Thread t = new Thread(new Runnable() {
@@ -337,19 +305,16 @@ public class ReentrantReadWriteLockTest
                     lock.readLock().unlock();
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.readLock().unlock();
-        } catch (Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.join();
+        lock.readLock().unlock();
     }
 
     /**
      * A writelock succeeds after reading threads unlock
      */
-    public void testWriteAfterMultipleReadLocks() {
+    public void testWriteAfterMultipleReadLocks() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.readLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -365,25 +330,20 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
     /**
      * Readlocks succeed after a writing thread unlocks
      */
-    public void testReadAfterWriteLock() {
+    public void testReadAfterWriteLock() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.writeLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -399,19 +359,14 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
     /**
@@ -429,7 +384,7 @@ public class ReentrantReadWriteLockTest
      * Read lock succeeds if write locked by current thread even if
      * other threads are waiting for readlock
      */
-    public void testReadHoldingWriteLock2() {
+    public void testReadHoldingWriteLock2() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.writeLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -445,30 +400,25 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
     /**
      *  Read lock succeeds if write locked by current thread even if
      * other threads are waiting for writelock
      */
-    public void testReadHoldingWriteLock3() {
+    public void testReadHoldingWriteLock3() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.writeLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -484,23 +434,18 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
 
@@ -508,7 +453,7 @@ public class ReentrantReadWriteLockTest
      *  Write lock succeeds if write locked by current thread even if
      * other threads are waiting for writelock
      */
-    public void testWriteHoldingWriteLock4() {
+    public void testWriteHoldingWriteLock4() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.writeLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -524,23 +469,18 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
 
@@ -559,7 +499,7 @@ public class ReentrantReadWriteLockTest
      * Fair Read lock succeeds if write locked by current thread even if
      * other threads are waiting for readlock
      */
-    public void testReadHoldingWriteLockFair2() {
+    public void testReadHoldingWriteLockFair2() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
 	lock.writeLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -575,23 +515,18 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
 
@@ -599,7 +534,7 @@ public class ReentrantReadWriteLockTest
      * Fair Read lock succeeds if write locked by current thread even if
      * other threads are waiting for writelock
      */
-    public void testReadHoldingWriteLockFair3() {
+    public void testReadHoldingWriteLockFair3() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
 	lock.writeLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -615,23 +550,18 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
 
@@ -639,7 +569,7 @@ public class ReentrantReadWriteLockTest
      * Fair Write lock succeeds if write locked by current thread even if
      * other threads are waiting for writelock
      */
-    public void testWriteHoldingWriteLockFair4() {
+    public void testWriteHoldingWriteLockFair4() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
 	lock.writeLock().lock();
 	Thread t1 = new Thread(new Runnable() {
@@ -655,33 +585,28 @@ public class ReentrantReadWriteLockTest
 		}
 	    });
 
-        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();
-        }
+        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());
     }
 
 
     /**
      * Read tryLock succeeds if readlocked but not writelocked
      */
-    public void testTryLockWhenReadLocked() {
+    public void testTryLockWhenReadLocked() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.readLock().lock();
 	Thread t = new Thread(new Runnable() {
@@ -690,13 +615,10 @@ public class ReentrantReadWriteLockTest
                     lock.readLock().unlock();
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.readLock().unlock();
-        } catch (Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.join();
+        lock.readLock().unlock();
     }
 
 
@@ -704,7 +626,7 @@ public class ReentrantReadWriteLockTest
     /**
      * write tryLock fails when readlocked
      */
-    public void testWriteTryLockWhenReadLocked() {
+    public void testWriteTryLockWhenReadLocked() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 	lock.readLock().lock();
 	Thread t = new Thread(new Runnable() {
@@ -712,20 +634,17 @@ public class ReentrantReadWriteLockTest
                     threadAssertFalse(lock.writeLock().tryLock());
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.readLock().unlock();
-        } catch (Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.join();
+        lock.readLock().unlock();
     }
 
 
     /**
      * Fair Read tryLock succeeds if readlocked but not writelocked
      */
-    public void testTryLockWhenReadLockedFair() {
+    public void testTryLockWhenReadLockedFair() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
 	lock.readLock().lock();
 	Thread t = new Thread(new Runnable() {
@@ -734,13 +653,10 @@ public class ReentrantReadWriteLockTest
                     lock.readLock().unlock();
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.readLock().unlock();
-        } catch (Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.join();
+        lock.readLock().unlock();
     }
 
 
@@ -748,7 +664,7 @@ public class ReentrantReadWriteLockTest
     /**
      * Fair write tryLock fails when readlocked
      */
-    public void testWriteTryLockWhenReadLockedFair() {
+    public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
 	lock.readLock().lock();
 	Thread t = new Thread(new Runnable() {
@@ -756,13 +672,10 @@ public class ReentrantReadWriteLockTest
                     threadAssertFalse(lock.writeLock().tryLock());
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.readLock().unlock();
-        } catch (Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.join();
+        lock.readLock().unlock();
     }
 
 
@@ -770,130 +683,85 @@ public class ReentrantReadWriteLockTest
     /**
      * write timed tryLock times out if locked
      */
-    public void testWriteTryLock_Timeout() {
+    public void testWriteTryLock_Timeout() throws InterruptedException {
 	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();
-        }
+	Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
+            }});
+
+        t.start();
+        t.join();
+        assertTrue(lock.writeLock().isHeldByCurrentThread());
+        lock.writeLock().unlock();
     }
 
     /**
      * read timed tryLock times out if write-locked
      */
-    public void testReadTryLock_Timeout() {
+    public void testReadTryLock_Timeout() throws InterruptedException {
 	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();
-        }
+	Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
+            }});
+
+        t.start();
+        t.join();
+        assertTrue(lock.writeLock().isHeldByCurrentThread());
+        lock.writeLock().unlock();
     }
 
 
     /**
      * write lockInterruptibly succeeds if lock free else is interruptible
      */
-    public void testWriteLockInterruptibly() {
+    public void testWriteLockInterruptibly() throws InterruptedException {
 	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();
-        }
+        lock.writeLock().lockInterruptibly();
+	Thread t = new Thread(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();
     }
 
     /**
      *  read lockInterruptibly succeeds if lock free else is interruptible
      */
-    public void testReadLockInterruptibly() {
+    public void testReadLockInterruptibly() throws InterruptedException {
 	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();
-        }
+        lock.writeLock().lockInterruptibly();
+	Thread t = new Thread(new CheckedInterruptedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.readLock().lockInterruptibly();
+            }});
+
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        t.join();
+        lock.writeLock().unlock();
     }
 
     /**
      * Calling await without holding lock throws IllegalMonitorStateException
      */
-    public void testAwait_IllegalMonitor() {
+    public void testAwait_IllegalMonitor() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             c.await();
             shouldThrow();
-        }
-        catch (IllegalMonitorStateException success) {
-        }
-        catch (Exception ex) {
-            shouldThrow();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
     /**
@@ -905,94 +773,66 @@ public class ReentrantReadWriteLockTest
         try {
             c.signal();
             shouldThrow();
-        }
-        catch (IllegalMonitorStateException success) {
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
     /**
      * awaitNanos without a signal times out
      */
-    public void testAwaitNanos_Timeout() {
+    public void testAwaitNanos_Timeout() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-        try {
-            lock.writeLock().lock();
-            long t = c.awaitNanos(100);
-            assertTrue(t <= 0);
-            lock.writeLock().unlock();
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+
+        lock.writeLock().lock();
+        long t = c.awaitNanos(100);
+        assertTrue(t <= 0);
+        lock.writeLock().unlock();
     }
 
 
     /**
      *  timed await without a signal times out
      */
-    public void testAwait_Timeout() {
+    public void testAwait_Timeout() throws InterruptedException {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-        try {
-            lock.writeLock().lock();
-            lock.writeLock().unlock();
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        lock.writeLock().lock();
+        assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+        lock.writeLock().unlock();
     }
 
     /**
      * awaitUntil without a signal times out
      */
-    public void testAwaitUntil_Timeout() {
+    public void testAwaitUntil_Timeout() throws InterruptedException {
 	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();
-        }
+        lock.writeLock().lock();
+        java.util.Date d = new java.util.Date();
+        assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
+        lock.writeLock().unlock();
     }
 
     /**
      * await returns when signalled
      */
-    public void testAwait() {
+    public void testAwait() throws InterruptedException {
 	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();
-                    }
-		}
-	    });
+	Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-        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();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        lock.writeLock().lock();
+        c.signal();
+        lock.writeLock().unlock();
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /** A helper class for uninterruptible wait tests */
@@ -1025,230 +865,167 @@ public class ReentrantReadWriteLockTest
     /**
      * awaitUninterruptibly doesn't abort on interrupt
      */
-    public void testAwaitUninterruptibly() {
+    public void testAwaitUninterruptibly() throws InterruptedException {
         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c);
 
-        try {
-            thread.start();
+        thread.start();
 
-            while (!thread.lockStarted) {
-                Thread.sleep(100);
-            }
-
-            lock.writeLock().lock();
-            try {
-                thread.interrupt();
-                thread.canAwake = true;
-                c.signal();
-            } finally {
-                lock.writeLock().unlock();
-            }
+        while (!thread.lockStarted) {
+            Thread.sleep(100);
+        }
 
-            thread.join();
-            assertTrue(thread.interrupted);
-            assertFalse(thread.isAlive());
-        } catch (Exception ex) {
-            unexpectedException();
+        lock.writeLock().lock();
+        try {
+            thread.interrupt();
+            thread.canAwake = true;
+            c.signal();
+        } finally {
+            lock.writeLock().unlock();
         }
+
+        thread.join();
+        assertTrue(thread.interrupted);
+        assertFalse(thread.isAlive());
     }
 
     /**
      * await is interruptible
      */
-    public void testAwait_Interrupt() {
+    public void testAwait_Interrupt() throws InterruptedException {
 	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) {
-                    }
-		}
-	    });
+	Thread t = new Thread(new CheckedInterruptedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /**
      * awaitNanos is interruptible
      */
-    public void testAwaitNanos_Interrupt() {
+    public void testAwaitNanos_Interrupt() throws InterruptedException {
 	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.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
-                        lock.writeLock().unlock();
-                        threadShouldThrow();
-		    }
-		    catch (InterruptedException success) {
-                    }
-		}
-	    });
+	Thread t = new Thread(new CheckedInterruptedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
+                lock.writeLock().unlock();
+            }});
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /**
      * awaitUntil is interruptible
      */
-    public void testAwaitUntil_Interrupt() {
+    public void testAwaitUntil_Interrupt() throws InterruptedException {
 	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) {
-                    }
-		}
-	    });
+	Thread t = new Thread(new CheckedInterruptedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                java.util.Date d = new java.util.Date();
+                c.awaitUntil(new java.util.Date(d.getTime() + 10000));
+                lock.writeLock().unlock();
+            }});
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /**
      * signalAll wakes up all threads
      */
-    public void testSignalAll() {
+    public void testSignalAll() throws InterruptedException {
 	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 t1 = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-	Thread t2 = 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 CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-        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();
-        }
+        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());
     }
 
     /**
      * A serialized lock deserializes as unlocked
      */
-    public void testSerialization() {
+    public void testSerialization() throws Exception {
         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();
-        }
+        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();
     }
 
     /**
      * hasQueuedThreads reports whether there are waiting threads
      */
-    public void testhasQueuedThreads() {
+    public void testhasQueuedThreads() throws InterruptedException {
 	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();
-        }
+        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();
     }
 
     /**
@@ -1259,104 +1036,91 @@ public class ReentrantReadWriteLockTest
         try {
             sync.hasQueuedThread(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * hasQueuedThread reports whether a thread is queued.
      */
-    public void testHasQueuedThread() {
+    public void testHasQueuedThread() throws InterruptedException {
 	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();
-        }
+        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();
     }
 
 
     /**
      * getQueueLength reports number of waiting threads
      */
-    public void testGetQueueLength() {
+    public void testGetQueueLength() throws InterruptedException {
 	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();
-        }
+        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();
     }
 
     /**
      * getQueuedThreads includes waiting threads
      */
-    public void testGetQueuedThreads() {
+    public void testGetQueuedThreads() throws InterruptedException {
 	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();
-        }
+        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();
     }
 
     /**
@@ -1367,10 +1131,7 @@ public class ReentrantReadWriteLockTest
         try {
             lock.hasWaiters(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -1381,10 +1142,7 @@ public class ReentrantReadWriteLockTest
         try {
             lock.getWaitQueueLength(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (NullPointerException success) {}
     }
 
 
@@ -1396,10 +1154,7 @@ public class ReentrantReadWriteLockTest
         try {
             lock.getWaitingThreads(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -1407,15 +1162,12 @@ public class ReentrantReadWriteLockTest
      */
     public void testHasWaitersIAE() {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = (lock.writeLock().newCondition());
+        final Condition c = lock.writeLock().newCondition();
 	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
         try {
             lock2.hasWaiters(c);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -1423,14 +1175,11 @@ public class ReentrantReadWriteLockTest
      */
     public void testHasWaitersIMSE() {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = (lock.writeLock().newCondition());
+        final Condition c = lock.writeLock().newCondition();
         try {
             lock.hasWaiters(c);
             shouldThrow();
-        } catch (IllegalMonitorStateException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
@@ -1439,15 +1188,12 @@ public class ReentrantReadWriteLockTest
      */
     public void testGetWaitQueueLengthIAE() {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = (lock.writeLock().newCondition());
+        final Condition c = lock.writeLock().newCondition();
 	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
         try {
             lock2.getWaitQueueLength(c);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -1455,14 +1201,11 @@ public class ReentrantReadWriteLockTest
      */
     public void testGetWaitQueueLengthIMSE() {
 	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-        final Condition c = (lock.writeLock().newCondition());
+        final Condition c = lock.writeLock().newCondition();
         try {
             lock.getWaitQueueLength(c);
             shouldThrow();
-        } catch (IllegalMonitorStateException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
@@ -1471,15 +1214,12 @@ public class ReentrantReadWriteLockTest
      */
     public void testGetWaitingThreadsIAE() {
 	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
-        final Condition c = (lock.writeLock().newCondition());
+        final Condition c = lock.writeLock().newCondition();
 	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
         try {
             lock2.getWaitingThreads(c);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -1487,163 +1227,121 @@ public class ReentrantReadWriteLockTest
      */
     public void testGetWaitingThreadsIMSE() {
 	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
-        final Condition c = (lock.writeLock().newCondition());
+        final Condition c = lock.writeLock().newCondition();
         try {
             lock.getWaitingThreads(c);
             shouldThrow();
-        } catch (IllegalMonitorStateException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
     /**
      * hasWaiters returns true when a thread is waiting, else false
      */
-    public void testHasWaiters() {
+    public void testHasWaiters() throws InterruptedException {
 	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();
-                    }
-		}
-	    });
+        final Condition c = lock.writeLock().newCondition();
+	Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                threadAssertFalse(lock.hasWaiters(c));
+                threadAssertEquals(0, lock.getWaitQueueLength(c));
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-        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();
-        }
+        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());
     }
 
     /**
      * getWaitQueueLength returns number of waiting threads
      */
-    public void testGetWaitQueueLength() {
+    public void testGetWaitQueueLength() throws InterruptedException {
 	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();
-                    }
-		}
-	    });
+        final Condition c = lock.writeLock().newCondition();
+	Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                threadAssertFalse(lock.hasWaiters(c));
+                threadAssertEquals(0, lock.getWaitQueueLength(c));
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-        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();
-        }
+        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());
     }
 
 
     /**
      * getWaitingThreads returns only and all waiting threads
      */
-    public void testGetWaitingThreads() {
+    public void testGetWaitingThreads() throws InterruptedException {
 	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 t1 = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-	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();
-                    }
-		}
-	    });
+	Thread t2 = new Thread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                lock.writeLock().lock();
+                threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
+                c.await();
+                lock.writeLock().unlock();
+            }});
 
-        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();
-        }
+        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());
     }
 
     /**