--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2009/11/17 14:45:32	1.34
+++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2009/11/21 02:07:27	1.35
@@ -14,10 +14,10 @@ import java.util.*;
 
 public class ReentrantReadWriteLockTest extends JSR166TestCase {
     public static void main(String[] args) {
-	junit.textui.TestRunner.run (suite());
+        junit.textui.TestRunner.run (suite());
     }
     public static Test suite() {
-	return new TestSuite(ReentrantReadWriteLockTest.class);
+        return new TestSuite(ReentrantReadWriteLockTest.class);
     }
 
     /**
@@ -61,15 +61,15 @@ public class ReentrantReadWriteLockTest
      * Constructor sets given fairness, and is in unlocked state
      */
     public void testConstructor() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
         assertFalse(rl.isFair());
         assertFalse(rl.isWriteLocked());
         assertEquals(0, rl.getReadLockCount());
-	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
+        ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
         assertTrue(r2.isFair());
         assertFalse(r2.isWriteLocked());
         assertEquals(0, r2.getReadLockCount());
-	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
+        ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
         assertFalse(r3.isFair());
         assertFalse(r3.isWriteLocked());
         assertEquals(0, r3.getReadLockCount());
@@ -79,7 +79,7 @@ public class ReentrantReadWriteLockTest
      * write-locking and read-locking an unlocked lock succeed
      */
     public void testLock() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
         rl.writeLock().lock();
         assertTrue(rl.isWriteLocked());
         assertTrue(rl.isWriteLockedByCurrentThread());
@@ -105,7 +105,7 @@ public class ReentrantReadWriteLockTest
      * locking an unlocked fair lock succeeds
      */
     public void testFairLock() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
         rl.writeLock().lock();
         assertTrue(rl.isWriteLocked());
         assertTrue(rl.isWriteLockedByCurrentThread());
@@ -130,45 +130,45 @@ public class ReentrantReadWriteLockTest
      * getWriteHoldCount returns number of recursive holds
      */
     public void testGetWriteHoldCount() {
-	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	for (int i = 1; i <= SIZE; i++) {
-	    lock.writeLock().lock();
-	    assertEquals(i,lock.getWriteHoldCount());
-	}
-	for (int i = SIZE; i > 0; i--) {
-	    lock.writeLock().unlock();
-	    assertEquals(i-1,lock.getWriteHoldCount());
-	}
+        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        for (int i = 1; i <= SIZE; i++) {
+            lock.writeLock().lock();
+            assertEquals(i,lock.getWriteHoldCount());
+        }
+        for (int i = SIZE; i > 0; i--) {
+            lock.writeLock().unlock();
+            assertEquals(i-1,lock.getWriteHoldCount());
+        }
     }
 
     /**
      * WriteLock.getHoldCount returns number of recursive holds
      */
     public void testGetHoldCount() {
-	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	for (int i = 1; i <= SIZE; i++) {
-	    lock.writeLock().lock();
-	    assertEquals(i,lock.writeLock().getHoldCount());
-	}
-	for (int i = SIZE; i > 0; i--) {
-	    lock.writeLock().unlock();
-	    assertEquals(i-1,lock.writeLock().getHoldCount());
-	}
+        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        for (int i = 1; i <= SIZE; i++) {
+            lock.writeLock().lock();
+            assertEquals(i,lock.writeLock().getHoldCount());
+        }
+        for (int i = SIZE; i > 0; i--) {
+            lock.writeLock().unlock();
+            assertEquals(i-1,lock.writeLock().getHoldCount());
+        }
     }
 
     /**
      * getReadHoldCount returns number of recursive holds
      */
     public void testGetReadHoldCount() {
-	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	for (int i = 1; i <= SIZE; i++) {
-	    lock.readLock().lock();
-	    assertEquals(i,lock.getReadHoldCount());
-	}
-	for (int i = SIZE; i > 0; i--) {
-	    lock.readLock().unlock();
-	    assertEquals(i-1,lock.getReadHoldCount());
-	}
+        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        for (int i = 1; i <= SIZE; i++) {
+            lock.readLock().lock();
+            assertEquals(i,lock.getReadHoldCount());
+        }
+        for (int i = SIZE; i > 0; i--) {
+            lock.readLock().unlock();
+            assertEquals(i-1,lock.getReadHoldCount());
+        }
     }
 
 
@@ -176,11 +176,11 @@ public class ReentrantReadWriteLockTest
      * write-unlocking an unlocked lock throws IllegalMonitorStateException
      */
     public void testUnlock_IllegalMonitorStateException() {
-	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
-	try {
-	    rl.writeLock().unlock();
-	    shouldThrow();
-	} catch (IllegalMonitorStateException success) {}
+        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
+        try {
+            rl.writeLock().unlock();
+            shouldThrow();
+        } catch (IllegalMonitorStateException success) {}
     }
 
 
@@ -188,8 +188,8 @@ public class ReentrantReadWriteLockTest
      * write-lockInterruptibly is interruptible
      */
     public void testWriteLockInterruptibly_Interrupted() throws Exception {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lockInterruptibly();
                 lock.writeLock().unlock();
@@ -210,9 +210,9 @@ public class ReentrantReadWriteLockTest
      * timed write-tryLock is interruptible
      */
     public void testWriteTryLock_Interrupted() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
             }});
@@ -227,9 +227,9 @@ public class ReentrantReadWriteLockTest
      * read-lockInterruptibly is interruptible
      */
     public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.readLock().lockInterruptibly();
             }});
@@ -246,9 +246,9 @@ public class ReentrantReadWriteLockTest
      * timed read-tryLock is interruptible
      */
     public void testReadTryLock_Interrupted() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
             }});
@@ -263,13 +263,13 @@ public class ReentrantReadWriteLockTest
      * write-tryLock fails if locked
      */
     public void testWriteTryLockWhenLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = new Thread(new Runnable() {
                 public void run() {
                     threadAssertFalse(lock.writeLock().tryLock());
-		}
-	    });
+                }
+            });
 
         t.start();
         t.join();
@@ -280,13 +280,13 @@ public class ReentrantReadWriteLockTest
      * read-tryLock fails if locked
      */
     public void testReadTryLockWhenLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = new Thread(new Runnable() {
                 public void run() {
                     threadAssertFalse(lock.readLock().tryLock());
-		}
-	    });
+                }
+            });
 
         t.start();
         t.join();
@@ -297,14 +297,14 @@ public class ReentrantReadWriteLockTest
      * Multiple threads can hold a read lock when not write-locked
      */
     public void testMultipleReadLocks() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t = new Thread(new Runnable() {
                 public void run() {
                     threadAssertTrue(lock.readLock().tryLock());
                     lock.readLock().unlock();
-		}
-	    });
+                }
+            });
 
         t.start();
         t.join();
@@ -315,20 +315,20 @@ public class ReentrantReadWriteLockTest
      * A writelock succeeds after reading threads unlock
      */
     public void testWriteAfterMultipleReadLocks() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.readLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.readLock().lock();
                     lock.readLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -344,20 +344,20 @@ public class ReentrantReadWriteLockTest
      * Readlocks succeed after a writing thread unlocks
      */
     public void testReadAfterWriteLock() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.readLock().lock();
                     lock.readLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.readLock().lock();
                     lock.readLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -373,8 +373,8 @@ public class ReentrantReadWriteLockTest
      * Read trylock succeeds if write locked by current thread
      */
     public void testReadHoldingWriteLock() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
         assertTrue(lock.readLock().tryLock());
         lock.readLock().unlock();
         lock.writeLock().unlock();
@@ -385,20 +385,20 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for readlock
      */
     public void testReadHoldingWriteLock2() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.readLock().lock();
                     lock.readLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.readLock().lock();
                     lock.readLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -419,20 +419,20 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for writelock
      */
     public void testReadHoldingWriteLock3() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -454,20 +454,20 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for writelock
      */
     public void testWriteHoldingWriteLock4() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -488,8 +488,8 @@ public class ReentrantReadWriteLockTest
      * Fair Read trylock succeeds if write locked by current thread
      */
     public void testReadHoldingWriteLockFair() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.writeLock().lock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
         assertTrue(lock.readLock().tryLock());
         lock.readLock().unlock();
         lock.writeLock().unlock();
@@ -500,20 +500,20 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for readlock
      */
     public void testReadHoldingWriteLockFair2() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.writeLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.readLock().lock();
                     lock.readLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.readLock().lock();
                     lock.readLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -535,20 +535,20 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for writelock
      */
     public void testReadHoldingWriteLockFair3() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.writeLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -570,20 +570,20 @@ public class ReentrantReadWriteLockTest
      * other threads are waiting for writelock
      */
     public void testWriteHoldingWriteLockFair4() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.writeLock().lock();
-	Thread t1 = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.writeLock().lock();
+        Thread t1 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
-	Thread t2 = new Thread(new Runnable() {
+                }
+            });
+        Thread t2 = new Thread(new Runnable() {
                 public void run() {
                     lock.writeLock().lock();
                     lock.writeLock().unlock();
-		}
-	    });
+                }
+            });
 
         t1.start();
         t2.start();
@@ -607,14 +607,14 @@ public class ReentrantReadWriteLockTest
      * Read tryLock succeeds if readlocked but not writelocked
      */
     public void testTryLockWhenReadLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t = new Thread(new Runnable() {
                 public void run() {
                     threadAssertTrue(lock.readLock().tryLock());
                     lock.readLock().unlock();
-		}
-	    });
+                }
+            });
 
         t.start();
         t.join();
@@ -627,13 +627,13 @@ public class ReentrantReadWriteLockTest
      * write tryLock fails when readlocked
      */
     public void testWriteTryLockWhenReadLocked() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.readLock().lock();
+        Thread t = new Thread(new Runnable() {
                 public void run() {
                     threadAssertFalse(lock.writeLock().tryLock());
-		}
-	    });
+                }
+            });
 
         t.start();
         t.join();
@@ -645,14 +645,14 @@ public class ReentrantReadWriteLockTest
      * Fair Read tryLock succeeds if readlocked but not writelocked
      */
     public void testTryLockWhenReadLockedFair() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.readLock().lock();
+        Thread t = new Thread(new Runnable() {
                 public void run() {
                     threadAssertTrue(lock.readLock().tryLock());
                     lock.readLock().unlock();
-		}
-	    });
+                }
+            });
 
         t.start();
         t.join();
@@ -665,13 +665,13 @@ public class ReentrantReadWriteLockTest
      * Fair write tryLock fails when readlocked
      */
     public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
-	lock.readLock().lock();
-	Thread t = new Thread(new Runnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+        lock.readLock().lock();
+        Thread t = new Thread(new Runnable() {
                 public void run() {
                     threadAssertFalse(lock.writeLock().tryLock());
-		}
-	    });
+                }
+            });
 
         t.start();
         t.join();
@@ -684,9 +684,9 @@ public class ReentrantReadWriteLockTest
      * write timed tryLock times out if locked
      */
     public void testWriteTryLock_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
             }});
@@ -701,9 +701,9 @@ public class ReentrantReadWriteLockTest
      * read timed tryLock times out if write-locked
      */
     public void testReadTryLock_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-	lock.writeLock().lock();
-	Thread t = new Thread(new CheckedRunnable() {
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        lock.writeLock().lock();
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
             }});
@@ -719,9 +719,9 @@ public class ReentrantReadWriteLockTest
      * write lockInterruptibly succeeds if lock free else is interruptible
      */
     public void testWriteLockInterruptibly() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         lock.writeLock().lockInterruptibly();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lockInterruptibly();
             }});
@@ -738,9 +738,9 @@ public class ReentrantReadWriteLockTest
      *  read lockInterruptibly succeeds if lock free else is interruptible
      */
     public void testReadLockInterruptibly() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         lock.writeLock().lockInterruptibly();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.readLock().lockInterruptibly();
             }});
@@ -756,7 +756,7 @@ public class ReentrantReadWriteLockTest
      * Calling await without holding lock throws IllegalMonitorStateException
      */
     public void testAwait_IllegalMonitor() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             c.await();
@@ -768,7 +768,7 @@ public class ReentrantReadWriteLockTest
      * Calling signal without holding lock throws IllegalMonitorStateException
      */
     public void testSignal_IllegalMonitor() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             c.signal();
@@ -780,7 +780,7 @@ public class ReentrantReadWriteLockTest
      * awaitNanos without a signal times out
      */
     public void testAwaitNanos_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
 
         lock.writeLock().lock();
@@ -794,7 +794,7 @@ public class ReentrantReadWriteLockTest
      *  timed await without a signal times out
      */
     public void testAwait_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         lock.writeLock().lock();
         assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
@@ -805,7 +805,7 @@ public class ReentrantReadWriteLockTest
      * awaitUntil without a signal times out
      */
     public void testAwaitUntil_Timeout() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         lock.writeLock().lock();
         java.util.Date d = new java.util.Date();
@@ -817,9 +817,9 @@ public class ReentrantReadWriteLockTest
      * await returns when signalled
      */
     public void testAwait() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedRunnable() {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.await();
@@ -894,9 +894,9 @@ public class ReentrantReadWriteLockTest
      * await is interruptible
      */
     public void testAwait_Interrupt() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.await();
@@ -914,9 +914,9 @@ public class ReentrantReadWriteLockTest
      * awaitNanos is interruptible
      */
     public void testAwaitNanos_Interrupt() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
@@ -934,9 +934,9 @@ public class ReentrantReadWriteLockTest
      * awaitUntil is interruptible
      */
     public void testAwaitUntil_Interrupt() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedInterruptedRunnable() {
+        Thread t = new Thread(new CheckedInterruptedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 java.util.Date d = new java.util.Date();
@@ -955,16 +955,16 @@ public class ReentrantReadWriteLockTest
      * signalAll wakes up all threads
      */
     public void testSignalAll() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t1 = new Thread(new CheckedRunnable() {
+        Thread t1 = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.await();
                 lock.writeLock().unlock();
             }});
 
-	Thread t2 = new Thread(new CheckedRunnable() {
+        Thread t2 = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 c.await();
@@ -1007,7 +1007,7 @@ public class ReentrantReadWriteLockTest
      * hasQueuedThreads reports whether there are waiting threads
      */
     public void testhasQueuedThreads() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
         assertFalse(lock.hasQueuedThreads());
@@ -1032,7 +1032,7 @@ public class ReentrantReadWriteLockTest
      * hasQueuedThread(null) throws NPE
      */
     public void testHasQueuedThreadNPE() {
-	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
         try {
             sync.hasQueuedThread(null);
             shouldThrow();
@@ -1043,7 +1043,7 @@ public class ReentrantReadWriteLockTest
      * hasQueuedThread reports whether a thread is queued.
      */
     public void testHasQueuedThread() throws InterruptedException {
-	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(sync));
         Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
         assertFalse(sync.hasQueuedThread(t1));
@@ -1074,7 +1074,7 @@ public class ReentrantReadWriteLockTest
      * getQueueLength reports number of waiting threads
      */
     public void testGetQueueLength() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
         assertEquals(0, lock.getQueueLength());
@@ -1099,7 +1099,7 @@ public class ReentrantReadWriteLockTest
      * getQueuedThreads includes waiting threads
      */
     public void testGetQueuedThreads() throws InterruptedException {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
         assertTrue(lock.getQueuedThreads().isEmpty());
@@ -1127,7 +1127,7 @@ public class ReentrantReadWriteLockTest
      * hasWaiters throws NPE if null
      */
     public void testHasWaitersNPE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         try {
             lock.hasWaiters(null);
             shouldThrow();
@@ -1138,7 +1138,7 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength throws NPE if null
      */
     public void testGetWaitQueueLengthNPE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         try {
             lock.getWaitQueueLength(null);
             shouldThrow();
@@ -1150,7 +1150,7 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads throws NPE if null
      */
     public void testGetWaitingThreadsNPE() {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         try {
             lock.getWaitingThreads(null);
             shouldThrow();
@@ -1161,9 +1161,9 @@ public class ReentrantReadWriteLockTest
      * hasWaiters throws IAE if not owned
      */
     public void testHasWaitersIAE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
         try {
             lock2.hasWaiters(c);
             shouldThrow();
@@ -1174,7 +1174,7 @@ public class ReentrantReadWriteLockTest
      * hasWaiters throws IMSE if not locked
      */
     public void testHasWaitersIMSE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             lock.hasWaiters(c);
@@ -1187,9 +1187,9 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength throws IAE if not owned
      */
     public void testGetWaitQueueLengthIAE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
         try {
             lock2.getWaitQueueLength(c);
             shouldThrow();
@@ -1200,7 +1200,7 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength throws IMSE if not locked
      */
     public void testGetWaitQueueLengthIMSE() {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             lock.getWaitQueueLength(c);
@@ -1213,9 +1213,9 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads throws IAE if not owned
      */
     public void testGetWaitingThreadsIAE() {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
         try {
             lock2.getWaitingThreads(c);
             shouldThrow();
@@ -1226,7 +1226,7 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads throws IMSE if not locked
      */
     public void testGetWaitingThreadsIMSE() {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
         try {
             lock.getWaitingThreads(c);
@@ -1239,9 +1239,9 @@ public class ReentrantReadWriteLockTest
      * hasWaiters returns true when a thread is waiting, else false
      */
     public void testHasWaiters() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedRunnable() {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 threadAssertFalse(lock.hasWaiters(c));
@@ -1270,9 +1270,9 @@ public class ReentrantReadWriteLockTest
      * getWaitQueueLength returns number of waiting threads
      */
     public void testGetWaitQueueLength() throws InterruptedException {
-	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t = new Thread(new CheckedRunnable() {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 threadAssertFalse(lock.hasWaiters(c));
@@ -1302,9 +1302,9 @@ public class ReentrantReadWriteLockTest
      * getWaitingThreads returns only and all waiting threads
      */
     public void testGetWaitingThreads() throws InterruptedException {
-	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
+        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
         final Condition c = lock.writeLock().newCondition();
-	Thread t1 = new Thread(new CheckedRunnable() {
+        Thread t1 = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
@@ -1312,7 +1312,7 @@ public class ReentrantReadWriteLockTest
                 lock.writeLock().unlock();
             }});
 
-	Thread t2 = new Thread(new CheckedRunnable() {
+        Thread t2 = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 lock.writeLock().lock();
                 threadAssertFalse(lock.getWaitingThreads(c).isEmpty());