--- jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java	2004/01/11 16:02:33	1.16
+++ jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java	2009/11/18 08:22:57	1.26
@@ -2,8 +2,8 @@
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
  * http://creativecommons.org/licenses/publicdomain
- * Other contributors include Andrew Wright, Jeffrey Hayes, 
- * Pat Fisher, Mike Judd. 
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
+ * Pat Fisher, Mike Judd.
  */
 
 
@@ -31,37 +31,33 @@ public class AbstractQueuedSynchronizerT
      */
     static class Mutex extends AbstractQueuedSynchronizer {
         public boolean isHeldExclusively() { return getState() == 1; }
-        
+
         public boolean tryAcquire(int acquires) {
-            assertTrue(acquires == 1); 
+            assertTrue(acquires == 1);
             return compareAndSetState(0, 1);
         }
-        
+
         public boolean tryRelease(int releases) {
             if (getState() == 0) throw new IllegalMonitorStateException();
             setState(0);
             return true;
         }
-        
+
         public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }
-        
-        public void lock() { 
-            acquire(1);
-        }
 
     }
 
-    
+
     /**
      * A simple latch class, to test shared mode.
      */
-    static class BooleanLatch extends AbstractQueuedSynchronizer { 
+    static class BooleanLatch extends AbstractQueuedSynchronizer {
         public boolean isSignalled() { return getState() != 0; }
 
         public int tryAcquireShared(int ignore) {
             return isSignalled()? 1 : -1;
         }
-        
+
         public boolean tryReleaseShared(int ignore) {
             setState(1);
             return true;
@@ -71,13 +67,13 @@ public class AbstractQueuedSynchronizerT
     /**
      * A runnable calling acquireInterruptibly
      */
-    class InterruptibleLockRunnable implements Runnable {
-        final Mutex lock;
-        InterruptibleLockRunnable(Mutex l) { lock = l; }
+    class InterruptibleSyncRunnable implements Runnable {
+        final Mutex sync;
+        InterruptibleSyncRunnable(Mutex l) { sync = l; }
         public void run() {
             try {
-                lock.acquireInterruptibly(1);
-            } catch(InterruptedException success){}
+                sync.acquireInterruptibly(1);
+            } catch (InterruptedException success) {}
         }
     }
 
@@ -86,39 +82,40 @@ public class AbstractQueuedSynchronizerT
      * A runnable calling acquireInterruptibly that expects to be
      * interrupted
      */
-    class InterruptedLockRunnable implements Runnable {
-        final Mutex lock;
-        InterruptedLockRunnable(Mutex l) { lock = l; }
+    class InterruptedSyncRunnable implements Runnable {
+        final Mutex sync;
+        InterruptedSyncRunnable(Mutex l) { sync = l; }
         public void run() {
             try {
-                lock.acquireInterruptibly(1);
+                sync.acquireInterruptibly(1);
                 threadShouldThrow();
-            } catch(InterruptedException success){}
+            } catch (InterruptedException success) {}
         }
     }
 
     /**
      * isHeldExclusively is false upon construction
      */
-    public void testIsHeldExclusively() { 
+    public void testIsHeldExclusively() {
 	Mutex rl = new Mutex();
         assertFalse(rl.isHeldExclusively());
     }
-    
+
     /**
-     * acquiring released lock succeeds
+     * acquiring released sync succeeds
      */
-    public void testAcquire() { 
+    public void testAcquire() {
 	Mutex rl = new Mutex();
         rl.acquire(1);
         assertTrue(rl.isHeldExclusively());
         rl.release(1);
+        assertFalse(rl.isHeldExclusively());
     }
 
     /**
-     * tryAcquire on an released lock succeeds
+     * tryAcquire on an released sync succeeds
      */
-    public void testTryAcquire() { 
+    public void testTryAcquire() {
 	Mutex rl = new Mutex();
         assertTrue(rl.tryAcquire(1));
         assertTrue(rl.isHeldExclusively());
@@ -128,401 +125,419 @@ public class AbstractQueuedSynchronizerT
     /**
      * hasQueuedThreads reports whether there are waiting threads
      */
-    public void testhasQueuedThreads() { 
-	final Mutex lock = new Mutex();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        try {
-            assertFalse(lock.hasQueuedThreads());
-            lock.acquire(1);
-            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.release(1);
-            Thread.sleep(SHORT_DELAY_MS);
-            assertFalse(lock.hasQueuedThreads());
-            t1.join();
-            t2.join();
-        } catch(Exception e){
-            unexpectedException();
-        }
-    } 
+    public void testhasQueuedThreads() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
+        Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
+        assertFalse(sync.hasQueuedThreads());
+        sync.acquire(1);
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.hasQueuedThreads());
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.hasQueuedThreads());
+        t1.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.hasQueuedThreads());
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(sync.hasQueuedThreads());
+        t1.join();
+        t2.join();
+    }
 
     /**
      * isQueued(null) throws NPE
      */
-    public void testIsQueuedNPE() { 
-	final Mutex lock = new Mutex();
+    public void testIsQueuedNPE() {
+	final Mutex sync = new Mutex();
         try {
-            lock.isQueued(null);
+            sync.isQueued(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * isQueued reports whether a thread is queued.
      */
-    public void testIsQueued() { 
-	final Mutex lock = new Mutex();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        try {
-            assertFalse(lock.isQueued(t1));
-            assertFalse(lock.isQueued(t2));
-            lock.acquire(1);
-            t1.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertTrue(lock.isQueued(t1));
-            t2.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertTrue(lock.isQueued(t1));
-            assertTrue(lock.isQueued(t2));
-            t1.interrupt();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertFalse(lock.isQueued(t1));
-            assertTrue(lock.isQueued(t2));
-            lock.release(1);
-            Thread.sleep(SHORT_DELAY_MS);
-            assertFalse(lock.isQueued(t1));
-            assertFalse(lock.isQueued(t2));
-            t1.join();
-            t2.join();
-        } catch(Exception e){
-            unexpectedException();
-        }
-    } 
+    public void testIsQueued() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
+        Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
+        assertFalse(sync.isQueued(t1));
+        assertFalse(sync.isQueued(t2));
+        sync.acquire(1);
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.isQueued(t1));
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.isQueued(t1));
+        assertTrue(sync.isQueued(t2));
+        t1.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(sync.isQueued(t1));
+        assertTrue(sync.isQueued(t2));
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(sync.isQueued(t1));
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(sync.isQueued(t2));
+        t1.join();
+        t2.join();
+    }
 
     /**
-     * getFirstQueuedThread returns first waiting thread or null is none
-     */
-    public void testGetFirstQueuedThread() { 
-	final Mutex lock = new Mutex();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        try {
-            assertNull(lock.getFirstQueuedThread());
-            lock.acquire(1);
-            t1.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertEquals(t1, lock.getFirstQueuedThread());
-            t2.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertEquals(t1, lock.getFirstQueuedThread());
-            t1.interrupt();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertEquals(t2, lock.getFirstQueuedThread());
-            lock.release(1);
-            Thread.sleep(SHORT_DELAY_MS);
-            assertNull(lock.getFirstQueuedThread());
-            t1.join();
-            t2.join();
-        } catch(Exception e){
-            unexpectedException();
-        }
-    } 
+     * getFirstQueuedThread returns first waiting thread or null if none
+     */
+    public void testGetFirstQueuedThread() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
+        Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
+        assertNull(sync.getFirstQueuedThread());
+        sync.acquire(1);
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertEquals(t1, sync.getFirstQueuedThread());
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertEquals(t1, sync.getFirstQueuedThread());
+        t1.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertEquals(t2, sync.getFirstQueuedThread());
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertNull(sync.getFirstQueuedThread());
+        t1.join();
+        t2.join();
+    }
 
 
     /**
      * hasContended reports false if no thread has ever blocked, else true
      */
-    public void testHasContended() { 
-	final Mutex lock = new Mutex();
-        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
-        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
-        try {
-            assertFalse(lock.hasContended());
-            lock.acquire(1);
-            t1.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertTrue(lock.hasContended());
-            t2.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertTrue(lock.hasContended());
-            t1.interrupt();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertTrue(lock.hasContended());
-            lock.release(1);
-            Thread.sleep(SHORT_DELAY_MS);
-            assertTrue(lock.hasContended());
-            t1.join();
-            t2.join();
-        } catch(Exception e){
-            unexpectedException();
-        }
-    } 
+    public void testHasContended() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
+        Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
+        assertFalse(sync.hasContended());
+        sync.acquire(1);
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.hasContended());
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.hasContended());
+        t1.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.hasContended());
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.hasContended());
+        t1.join();
+        t2.join();
+    }
+
+    /**
+     * getQueuedThreads includes waiting threads
+     */
+    public void testGetQueuedThreads() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
+        Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
+        assertTrue(sync.getQueuedThreads().isEmpty());
+        sync.acquire(1);
+        assertTrue(sync.getQueuedThreads().isEmpty());
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getQueuedThreads().contains(t1));
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getQueuedThreads().contains(t1));
+        assertTrue(sync.getQueuedThreads().contains(t2));
+        t1.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(sync.getQueuedThreads().contains(t1));
+        assertTrue(sync.getQueuedThreads().contains(t2));
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getQueuedThreads().isEmpty());
+        t1.join();
+        t2.join();
+    }
+
+    /**
+     * getExclusiveQueuedThreads includes waiting threads
+     */
+    public void testGetExclusiveQueuedThreads() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
+        Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
+        assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
+        sync.acquire(1);
+        assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
+        assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
+        t1.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(sync.getExclusiveQueuedThreads().contains(t1));
+        assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
+        t1.join();
+        t2.join();
+    }
+
+    /**
+     * getSharedQueuedThreads does not include exclusively waiting threads
+     */
+    public void testGetSharedQueuedThreads() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
+        Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
+        assertTrue(sync.getSharedQueuedThreads().isEmpty());
+        sync.acquire(1);
+        assertTrue(sync.getSharedQueuedThreads().isEmpty());
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getSharedQueuedThreads().isEmpty());
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getSharedQueuedThreads().isEmpty());
+        t1.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getSharedQueuedThreads().isEmpty());
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.getSharedQueuedThreads().isEmpty());
+        t1.join();
+        t2.join();
+    }
 
     /**
      * tryAcquireNanos is interruptible.
      */
-    public void testInterruptedException2() { 
-	final Mutex lock = new Mutex();
-	lock.acquire(1);
+    public void testInterruptedException2() {
+	final Mutex sync = new Mutex();
+	sync.acquire(1);
 	Thread t = new Thread(new Runnable() {
                 public void run() {
                     try {
-			lock.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
+			sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
 			threadShouldThrow();
-		    } catch(InterruptedException success){}
+		    } catch (InterruptedException success) {}
 		}
 	    });
-        try {
-            t.start();
-            t.interrupt();
-        } catch(Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        t.interrupt();
     }
 
 
     /**
-     * TryAcquire on a locked lock fails
+     * TryAcquire on exclusively held sync fails
      */
-    public void testTryAcquireWhenLocked() { 
-	final Mutex lock = new Mutex();
-	lock.acquire(1);
+    public void testTryAcquireWhenSynced() throws InterruptedException {
+	final Mutex sync = new Mutex();
+	sync.acquire(1);
 	Thread t = new Thread(new Runnable() {
                 public void run() {
-                    threadAssertFalse(lock.tryAcquire(1));
+                    threadAssertFalse(sync.tryAcquire(1));
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.release(1);
-        } catch(Exception e){
-            unexpectedException();
-        }
-    } 
+
+        t.start();
+        t.join();
+        sync.release(1);
+    }
 
     /**
-     * tryAcquireNanos on a locked lock times out
+     * tryAcquireNanos on an exclusively held sync times out
      */
-    public void testAcquireNanos_Timeout() { 
-	final Mutex lock = new Mutex();
-	lock.acquire(1);
+    public void testAcquireNanos_Timeout() throws InterruptedException {
+	final Mutex sync = new Mutex();
+	sync.acquire(1);
 	Thread t = new Thread(new Runnable() {
                 public void run() {
 		    try {
-                        threadAssertFalse(lock.tryAcquireNanos(1, 1000 * 1000));
+                        threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));
                     } catch (Exception ex) {
                         threadUnexpectedException();
                     }
 		}
 	    });
-        try {
-            t.start();
-            t.join();
-            lock.release(1);
-        } catch(Exception e){
-            unexpectedException();
-        }
-    } 
-    
-   
+
+        t.start();
+        t.join();
+        sync.release(1);
+    }
+
+
     /**
      * getState is true when acquired and false when not
      */
-    public void testGetState() {
-	final Mutex lock = new Mutex();
-	lock.acquire(1);
-	assertTrue(lock.isHeldExclusively());
-	lock.release(1);
-	assertFalse(lock.isHeldExclusively());
-	Thread t = new Thread(new Runnable() { 
+    public void testGetState() throws InterruptedException {
+	final Mutex sync = new Mutex();
+	sync.acquire(1);
+	assertTrue(sync.isHeldExclusively());
+	sync.release(1);
+	assertFalse(sync.isHeldExclusively());
+	Thread t = new Thread(new Runnable() {
 		public void run() {
-		    lock.acquire(1);
+		    sync.acquire(1);
 		    try {
 			Thread.sleep(SMALL_DELAY_MS);
 		    }
-		    catch(Exception e) {
+		    catch (Exception e) {
                         threadUnexpectedException();
                     }
-		    lock.release(1);
+		    sync.release(1);
 		}
 	    });
-	try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            assertTrue(lock.isHeldExclusively());
-            t.join();
-            assertFalse(lock.isHeldExclusively());
-        } catch(Exception e){
-            unexpectedException();
-        }
+
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        assertTrue(sync.isHeldExclusively());
+        t.join();
+        assertFalse(sync.isHeldExclusively());
     }
 
 
     /**
      * acquireInterruptibly is interruptible.
      */
-    public void testAcquireInterruptibly1() { 
-	final Mutex lock = new Mutex();
-	lock.acquire(1);
-	Thread t = new Thread(new InterruptedLockRunnable(lock));
-        try {
-            t.start();
-            t.interrupt();
-            lock.release(1);
-            t.join();
-        } catch(Exception e){
-            unexpectedException();
-        }
-    } 
+    public void testAcquireInterruptibly1() throws InterruptedException {
+	final Mutex sync = new Mutex();
+	sync.acquire(1);
+	Thread t = new Thread(new InterruptedSyncRunnable(sync));
+
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.release(1);
+        t.join();
+    }
 
     /**
      * acquireInterruptibly succeeds when released, else is interruptible
      */
-    public void testAcquireInterruptibly2() {
-	final Mutex lock = new Mutex();	
-	try {
-            lock.acquireInterruptibly(1);
-        } catch(Exception e) {
-            unexpectedException();
-        }
-	Thread t = new Thread(new InterruptedLockRunnable(lock));
-        try {
-            t.start();
-            t.interrupt();
-            assertTrue(lock.isHeldExclusively());
-            t.join();
-        } catch(Exception e){
-            unexpectedException();
-        }
+    public void testAcquireInterruptibly2() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        sync.acquireInterruptibly(1);
+	Thread t = new Thread(new InterruptedSyncRunnable(sync));
+        t.start();
+        t.interrupt();
+        assertTrue(sync.isHeldExclusively());
+        t.join();
     }
 
     /**
-     * owns is true for a condition created by lock else false
+     * owns is true for a condition created by sync else false
      */
     public void testOwns() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-        final Mutex lock2 = new Mutex();
-        assertTrue(lock.owns(c));
-        assertFalse(lock2.owns(c));
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+        final Mutex sync2 = new Mutex();
+        assertTrue(sync.owns(c));
+        assertFalse(sync2.owns(c));
     }
 
     /**
-     * Calling await without holding lock throws IllegalMonitorStateException
+     * Calling await without holding sync throws IllegalMonitorStateException
      */
-    public void testAwait_IllegalMonitor() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
+    public void testAwait_IllegalMonitor() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {
             c.await();
             shouldThrow();
         }
-        catch (IllegalMonitorStateException success) {
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        catch (IllegalMonitorStateException success) {}
     }
 
     /**
-     * Calling signal without holding lock throws IllegalMonitorStateException
+     * Calling signal without holding sync throws IllegalMonitorStateException
      */
     public void testSignal_IllegalMonitor() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {
             c.signal();
             shouldThrow();
         }
-        catch (IllegalMonitorStateException success) {
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        catch (IllegalMonitorStateException success) {}
     }
 
     /**
      * awaitNanos without a signal times out
      */
-    public void testAwaitNanos_Timeout() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-        try {
-            lock.acquire(1);
-            long t = c.awaitNanos(100);
-            assertTrue(t <= 0);
-            lock.release(1);
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+    public void testAwaitNanos_Timeout() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+        sync.acquire(1);
+        long t = c.awaitNanos(100);
+        assertTrue(t <= 0);
+        sync.release(1);
     }
 
     /**
-     *  timed await without a signal times out
-     */
-    public void testAwait_Timeout() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-        try {
-            lock.acquire(1);
-            assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-            lock.release(1);
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+     *  Timed await without a signal times out
+     */
+    public void testAwait_Timeout() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+        sync.acquire(1);
+        assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+        sync.release(1);
     }
 
     /**
      * awaitUntil without a signal times out
      */
-    public void testAwaitUntil_Timeout() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-        try {
-            lock.acquire(1);
-            java.util.Date d = new java.util.Date();
-            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
-            lock.release(1);
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+    public void testAwaitUntil_Timeout() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+        sync.acquire(1);
+        java.util.Date d = new java.util.Date();
+        assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
+        sync.release(1);
     }
 
     /**
      * await returns when signalled
      */
-    public void testAwait() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t = new Thread(new Runnable() { 
+    public void testAwait() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
+			sync.acquire(1);
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            c.signal();
-            lock.release(1);
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.acquire(1);
+        c.signal();
+        sync.release(1);
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
 
@@ -531,28 +546,22 @@ public class AbstractQueuedSynchronizerT
      * hasWaiters throws NPE if null
      */
     public void testHasWaitersNPE() {
-	final Mutex lock = new Mutex();
+	final Mutex sync = new Mutex();
         try {
-            lock.hasWaiters(null);
+            sync.hasWaiters(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * getWaitQueueLength throws NPE if null
      */
     public void testGetWaitQueueLengthNPE() {
-	final Mutex lock = new Mutex();
+	final Mutex sync = new Mutex();
         try {
-            lock.getWaitQueueLength(null);
+            sync.getWaitQueueLength(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (NullPointerException success) {}
     }
 
 
@@ -560,14 +569,11 @@ public class AbstractQueuedSynchronizerT
      * getWaitingThreads throws NPE if null
      */
     public void testGetWaitingThreadsNPE() {
-	final Mutex lock = new Mutex();
+	final Mutex sync = new Mutex();
         try {
-            lock.getWaitingThreads(null);
+            sync.getWaitingThreads(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (NullPointerException success) {}
     }
 
 
@@ -575,31 +581,25 @@ public class AbstractQueuedSynchronizerT
      * hasWaiters throws IAE if not owned
      */
     public void testHasWaitersIAE() {
-	final Mutex lock = new Mutex();
-        final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());
-	final Mutex lock2 = new Mutex();
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	final Mutex sync2 = new Mutex();
         try {
-            lock2.hasWaiters(c);
+            sync2.hasWaiters(c);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
-     * hasWaiters throws IMSE if not locked
+     * hasWaiters throws IMSE if not synced
      */
     public void testHasWaitersIMSE() {
-	final Mutex lock = new Mutex();
-        final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {
-            lock.hasWaiters(c);
+            sync.hasWaiters(c);
             shouldThrow();
-        } catch (IllegalMonitorStateException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
@@ -607,31 +607,25 @@ public class AbstractQueuedSynchronizerT
      * getWaitQueueLength throws IAE if not owned
      */
     public void testGetWaitQueueLengthIAE() {
-	final Mutex lock = new Mutex();
-        final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());
-	final Mutex lock2 = new Mutex();
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	final Mutex sync2 = new Mutex();
         try {
-            lock2.getWaitQueueLength(c);
+            sync2.getWaitQueueLength(c);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
-     * getWaitQueueLength throws IMSE if not locked
+     * getWaitQueueLength throws IMSE if not synced
      */
     public void testGetWaitQueueLengthIMSE() {
-	final Mutex lock = new Mutex();
-        final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {
-            lock.getWaitQueueLength(c);
+            sync.getWaitQueueLength(c);
             shouldThrow();
-        } catch (IllegalMonitorStateException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
@@ -639,31 +633,25 @@ public class AbstractQueuedSynchronizerT
      * getWaitingThreads throws IAE if not owned
      */
     public void testGetWaitingThreadsIAE() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());
-	final Mutex lock2 = new Mutex();	
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	final Mutex sync2 = new Mutex();
         try {
-            lock2.getWaitingThreads(c);
+            sync2.getWaitingThreads(c);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
-     * getWaitingThreads throws IMSE if not locked
+     * getWaitingThreads throws IMSE if not synced
      */
     public void testGetWaitingThreadsIMSE() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {
-            lock.getWaitingThreads(c);
+            sync.getWaitingThreads(c);
             shouldThrow();
-        } catch (IllegalMonitorStateException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
@@ -671,167 +659,152 @@ public class AbstractQueuedSynchronizerT
     /**
      * hasWaiters returns true when a thread is waiting, else false
      */
-    public void testHasWaiters() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t = new Thread(new Runnable() { 
+    public void testHasWaiters() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
-                        threadAssertFalse(lock.hasWaiters(c));
-                        threadAssertEquals(0, lock.getWaitQueueLength(c));
+			sync.acquire(1);
+                        threadAssertFalse(sync.hasWaiters(c));
+                        threadAssertEquals(0, sync.getWaitQueueLength(c));
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            assertTrue(lock.hasWaiters(c));
-            assertEquals(1, lock.getWaitQueueLength(c));
-            c.signal();
-            lock.release(1);
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            assertFalse(lock.hasWaiters(c));
-            assertEquals(0, lock.getWaitQueueLength(c));
-            lock.release(1);
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.acquire(1);
+        assertTrue(sync.hasWaiters(c));
+        assertEquals(1, sync.getWaitQueueLength(c));
+        c.signal();
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.acquire(1);
+        assertFalse(sync.hasWaiters(c));
+        assertEquals(0, sync.getWaitQueueLength(c));
+        sync.release(1);
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /**
      * getWaitQueueLength returns number of waiting threads
      */
-    public void testGetWaitQueueLength() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t1 = new Thread(new Runnable() { 
+    public void testGetWaitQueueLength() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t1 = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
-                        threadAssertFalse(lock.hasWaiters(c));
-                        threadAssertEquals(0, lock.getWaitQueueLength(c));
+			sync.acquire(1);
+                        threadAssertFalse(sync.hasWaiters(c));
+                        threadAssertEquals(0, sync.getWaitQueueLength(c));
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-	Thread t2 = new Thread(new Runnable() { 
+	Thread t2 = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
-                        threadAssertTrue(lock.hasWaiters(c));
-                        threadAssertEquals(1, lock.getWaitQueueLength(c));
+			sync.acquire(1);
+                        threadAssertTrue(sync.hasWaiters(c));
+                        threadAssertEquals(1, sync.getWaitQueueLength(c));
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-        try {
-            t1.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t2.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            assertTrue(lock.hasWaiters(c));
-            assertEquals(2, lock.getWaitQueueLength(c));
-            c.signalAll();
-            lock.release(1);
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            assertFalse(lock.hasWaiters(c));
-            assertEquals(0, lock.getWaitQueueLength(c));
-            lock.release(1);
-            t1.join(SHORT_DELAY_MS);
-            t2.join(SHORT_DELAY_MS);
-            assertFalse(t1.isAlive());
-            assertFalse(t2.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.acquire(1);
+        assertTrue(sync.hasWaiters(c));
+        assertEquals(2, sync.getWaitQueueLength(c));
+        c.signalAll();
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.acquire(1);
+        assertFalse(sync.hasWaiters(c));
+        assertEquals(0, sync.getWaitQueueLength(c));
+        sync.release(1);
+        t1.join(SHORT_DELAY_MS);
+        t2.join(SHORT_DELAY_MS);
+        assertFalse(t1.isAlive());
+        assertFalse(t2.isAlive());
     }
 
     /**
      * getWaitingThreads returns only and all waiting threads
      */
-    public void testGetWaitingThreads() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t1 = new Thread(new Runnable() { 
+    public void testGetWaitingThreads() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t1 = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
-                        threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
+			sync.acquire(1);
+                        threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-	Thread t2 = new Thread(new Runnable() { 
+	Thread t2 = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
-                        threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
+			sync.acquire(1);
+                        threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-        try {
-            lock.acquire(1);
-            assertTrue(lock.getWaitingThreads(c).isEmpty());
-            lock.release(1);
-            t1.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t2.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            assertTrue(lock.hasWaiters(c));
-            assertTrue(lock.getWaitingThreads(c).contains(t1));
-            assertTrue(lock.getWaitingThreads(c).contains(t2));
-            c.signalAll();
-            lock.release(1);
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            assertFalse(lock.hasWaiters(c));
-            assertTrue(lock.getWaitingThreads(c).isEmpty());
-            lock.release(1);
-            t1.join(SHORT_DELAY_MS);
-            t2.join(SHORT_DELAY_MS);
-            assertFalse(t1.isAlive());
-            assertFalse(t2.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        sync.acquire(1);
+        assertTrue(sync.getWaitingThreads(c).isEmpty());
+        sync.release(1);
+        t1.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t2.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.acquire(1);
+        assertTrue(sync.hasWaiters(c));
+        assertTrue(sync.getWaitingThreads(c).contains(t1));
+        assertTrue(sync.getWaitingThreads(c).contains(t2));
+        c.signalAll();
+        sync.release(1);
+        Thread.sleep(SHORT_DELAY_MS);
+        sync.acquire(1);
+        assertFalse(sync.hasWaiters(c));
+        assertTrue(sync.getWaitingThreads(c).isEmpty());
+        sync.release(1);
+        t1.join(SHORT_DELAY_MS);
+        t2.join(SHORT_DELAY_MS);
+        assertFalse(t1.isAlive());
+        assertFalse(t2.isAlive());
     }
 
 
@@ -839,174 +812,148 @@ public class AbstractQueuedSynchronizerT
     /**
      * awaitUninterruptibly doesn't abort on interrupt
      */
-    public void testAwaitUninterruptibly() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t = new Thread(new Runnable() { 
+    public void testAwaitUninterruptibly() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t = new Thread(new Runnable() {
 		public void run() {
-                    lock.acquire(1);
+                    sync.acquire(1);
                     c.awaitUninterruptibly();
-                    lock.release(1);
+                    sync.release(1);
 		}
 	    });
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-            lock.acquire(1);
-            c.signal();
-            lock.release(1);
-            assert(t.isInterrupted());
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        sync.acquire(1);
+        c.signal();
+        sync.release(1);
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /**
      * await is interruptible
      */
-    public void testAwait_Interrupt() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t = new Thread(new Runnable() { 
+    public void testAwait_Interrupt() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
+			sync.acquire(1);
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
                         threadShouldThrow();
 		    }
-		    catch(InterruptedException success) {
+		    catch (InterruptedException success) {
                     }
 		}
 	    });
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /**
      * awaitNanos is interruptible
      */
-    public void testAwaitNanos_Interrupt() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t = new Thread(new Runnable() { 
+    public void testAwaitNanos_Interrupt() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
+			sync.acquire(1);
                         c.awaitNanos(1000 * 1000 * 1000); // 1 sec
-                        lock.release(1);
+                        sync.release(1);
                         threadShouldThrow();
 		    }
-		    catch(InterruptedException success) {
+		    catch (InterruptedException success) {
                     }
 		}
 	    });
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        t.start();
+        Thread.sleep(SHORT_DELAY_MS);
+        t.interrupt();
+        t.join(SHORT_DELAY_MS);
+        assertFalse(t.isAlive());
     }
 
     /**
      * awaitUntil is interruptible
      */
-    public void testAwaitUntil_Interrupt() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t = new Thread(new Runnable() { 
+    public void testAwaitUntil_Interrupt() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
+			sync.acquire(1);
                         java.util.Date d = new java.util.Date();
                         c.awaitUntil(new java.util.Date(d.getTime() + 10000));
-                        lock.release(1);
+                        sync.release(1);
                         threadShouldThrow();
 		    }
-		    catch(InterruptedException success) {
+		    catch (InterruptedException success) {
                     }
 		}
 	    });
 
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-            t.join(SHORT_DELAY_MS);
-            assertFalse(t.isAlive());
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        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() {
-	final Mutex lock = new Mutex();	
-        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
-	Thread t1 = new Thread(new Runnable() { 
+    public void testSignalAll() throws InterruptedException {
+	final Mutex sync = new Mutex();
+        final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
+	Thread t1 = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
+			sync.acquire(1);
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-	Thread t2 = new Thread(new Runnable() { 
+	Thread t2 = new Thread(new Runnable() {
 		public void run() {
 		    try {
-			lock.acquire(1);
+			sync.acquire(1);
                         c.await();
-                        lock.release(1);
+                        sync.release(1);
 		    }
-		    catch(InterruptedException e) {
+		    catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
 
-        try {
-            t1.start();
-            t2.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            lock.acquire(1);
-            c.signalAll();
-            lock.release(1);
-            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);
+        sync.acquire(1);
+        c.signalAll();
+        sync.release(1);
+        t1.join(SHORT_DELAY_MS);
+        t2.join(SHORT_DELAY_MS);
+        assertFalse(t1.isAlive());
+        assertFalse(t2.isAlive());
     }
 
 
@@ -1014,36 +961,31 @@ public class AbstractQueuedSynchronizerT
      * toString indicates current state
      */
     public void testToString() {
-        Mutex lock = new Mutex();
-        String us = lock.toString();
+        Mutex sync = new Mutex();
+        String us = sync.toString();
         assertTrue(us.indexOf("State = 0") >= 0);
-        lock.acquire(1);
-        String ls = lock.toString();
+        sync.acquire(1);
+        String ls = sync.toString();
         assertTrue(ls.indexOf("State = 1") >= 0);
     }
 
     /**
      * A serialized AQS deserializes with current state
      */
-    public void testSerialization() {
+    public void testSerialization() throws Exception {
         Mutex l = new Mutex();
         l.acquire(1);
         assertTrue(l.isHeldExclusively());
 
-        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));
-            Mutex r = (Mutex) in.readObject();
-            assertTrue(r.isHeldExclusively());
-        } 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));
+        Mutex r = (Mutex) in.readObject();
+        assertTrue(r.isHeldExclusively());
     }
 
 
@@ -1058,7 +1000,7 @@ public class AbstractQueuedSynchronizerT
     }
 
     /**
-     * release and has no effect when already signalled
+     * releaseShared has no effect when already signalled
      */
     public void testReleaseShared() {
 	final BooleanLatch l = new BooleanLatch();
@@ -1072,7 +1014,7 @@ public class AbstractQueuedSynchronizerT
     /**
      * acquireSharedInterruptibly returns after release, but not before
      */
-    public void testAcquireSharedInterruptibly() {
+    public void testAcquireSharedInterruptibly() throws InterruptedException {
 	final BooleanLatch l = new BooleanLatch();
 
 	Thread t = new Thread(new Runnable() {
@@ -1081,28 +1023,25 @@ public class AbstractQueuedSynchronizerT
                         threadAssertFalse(l.isSignalled());
 			l.acquireSharedInterruptibly(0);
                         threadAssertTrue(l.isSignalled());
-		    } catch(InterruptedException e){
+		    } catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
-	try {
-            t.start();
-            assertFalse(l.isSignalled());
-            Thread.sleep(SHORT_DELAY_MS);
-            l.releaseShared(0);
-            assertTrue(l.isSignalled());
-            t.join();
-        } catch (InterruptedException e){
-            unexpectedException();
-        }
+
+        t.start();
+        assertFalse(l.isSignalled());
+        Thread.sleep(SHORT_DELAY_MS);
+        l.releaseShared(0);
+        assertTrue(l.isSignalled());
+        t.join();
     }
-    
+
 
     /**
      * acquireSharedTimed returns after release
      */
-    public void testAsquireSharedTimed() {
+    public void testAsquireSharedTimed() throws InterruptedException {
 	final BooleanLatch l = new BooleanLatch();
 
 	Thread t = new Thread(new Runnable() {
@@ -1112,27 +1051,24 @@ public class AbstractQueuedSynchronizerT
 			threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
                         threadAssertTrue(l.isSignalled());
 
-		    } catch(InterruptedException e){
+		    } catch (InterruptedException e) {
                         threadUnexpectedException();
                     }
 		}
 	    });
-	try {
-            t.start();
-            assertFalse(l.isSignalled());
-            Thread.sleep(SHORT_DELAY_MS);
-            l.releaseShared(0);
-            assertTrue(l.isSignalled());
-            t.join();
-        } catch (InterruptedException e){
-            unexpectedException();
-        }
+
+        t.start();
+        assertFalse(l.isSignalled());
+        Thread.sleep(SHORT_DELAY_MS);
+        l.releaseShared(0);
+        assertTrue(l.isSignalled());
+        t.join();
     }
-    
+
     /**
      * acquireSharedInterruptibly throws IE if interrupted before released
      */
-    public void testAcquireSharedInterruptibly_InterruptedException() {
+    public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
         final BooleanLatch l = new BooleanLatch();
         Thread t = new Thread(new Runnable() {
                 public void run() {
@@ -1140,68 +1076,56 @@ public class AbstractQueuedSynchronizerT
                         threadAssertFalse(l.isSignalled());
                         l.acquireSharedInterruptibly(0);
                         threadShouldThrow();
-                    } catch(InterruptedException success){}
+                    } catch (InterruptedException success) {}
                 }
             });
 	t.start();
-	try {
-            assertFalse(l.isSignalled());
-            t.interrupt();
-            t.join();
-        } catch (InterruptedException e){
-            unexpectedException();
-        }
+        assertFalse(l.isSignalled());
+        t.interrupt();
+        t.join();
     }
 
     /**
      * acquireSharedTimed throws IE if interrupted before released
      */
-    public void testAcquireSharedNanos_InterruptedException() {
+    public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {
         final BooleanLatch l = new BooleanLatch();
         Thread t = new Thread(new Runnable() {
                 public void run() {
                     try {
                         threadAssertFalse(l.isSignalled());
                         l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
-                        threadShouldThrow();                        
-                    } catch(InterruptedException success){}
+                        threadShouldThrow();
+                    } catch (InterruptedException success) {}
                 }
             });
         t.start();
-        try {
-            Thread.sleep(SHORT_DELAY_MS);
-            assertFalse(l.isSignalled());
-            t.interrupt();
-            t.join();
-        } catch (InterruptedException e){
-            unexpectedException();
-        }
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(l.isSignalled());
+        t.interrupt();
+        t.join();
     }
 
     /**
      * acquireSharedTimed times out if not released before timeout
      */
-    public void testAcquireSharedNanos_Timeout() {
+    public void testAcquireSharedNanos_Timeout() throws InterruptedException {
         final BooleanLatch l = new BooleanLatch();
         Thread t = new Thread(new Runnable() {
                 public void run() {
                     try {
                         threadAssertFalse(l.isSignalled());
                         threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
-                    } catch(InterruptedException ie){
+                    } catch (InterruptedException ie) {
                         threadUnexpectedException();
                     }
                 }
             });
         t.start();
-        try {
-            Thread.sleep(SHORT_DELAY_MS);
-            assertFalse(l.isSignalled());
-            t.join();
-        } catch (InterruptedException e){
-            unexpectedException();
-        }
+        Thread.sleep(SHORT_DELAY_MS);
+        assertFalse(l.isSignalled());
+        t.join();
     }
 
-    
+
 }