--- jsr166/src/test/tck/ReentrantLockTest.java	2015/07/03 01:25:15	1.62
+++ jsr166/src/test/tck/ReentrantLockTest.java	2017/05/14 02:03:15	1.65
@@ -209,7 +209,7 @@ public class ReentrantLockTest extends J
     public void testUnlock_IMSE()      { testUnlock_IMSE(false); }
     public void testUnlock_IMSE_fair() { testUnlock_IMSE(true); }
     public void testUnlock_IMSE(boolean fair) {
-        ReentrantLock lock = new ReentrantLock(fair);
+        final ReentrantLock lock = new ReentrantLock(fair);
         try {
             lock.unlock();
             shouldThrow();
@@ -399,11 +399,11 @@ public class ReentrantLockTest extends J
     public void testTryLock_Timeout_fair() { testTryLock_Timeout(true); }
     public void testTryLock_Timeout(boolean fair) {
         final PublicReentrantLock lock = new PublicReentrantLock(fair);
+        final long timeoutMillis = timeoutMillis();
         lock.lock();
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 long startTime = System.nanoTime();
-                long timeoutMillis = 10;
                 assertFalse(lock.tryLock(timeoutMillis, MILLISECONDS));
                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
             }});
@@ -418,7 +418,7 @@ public class ReentrantLockTest extends J
     public void testGetHoldCount()      { testGetHoldCount(false); }
     public void testGetHoldCount_fair() { testGetHoldCount(true); }
     public void testGetHoldCount(boolean fair) {
-        ReentrantLock lock = new ReentrantLock(fair);
+        final ReentrantLock lock = new ReentrantLock(fair);
         for (int i = 1; i <= SIZE; i++) {
             lock.lock();
             assertEquals(i, lock.getHoldCount());
@@ -435,8 +435,8 @@ public class ReentrantLockTest extends J
     public void testIsLocked()      { testIsLocked(false); }
     public void testIsLocked_fair() { testIsLocked(true); }
     public void testIsLocked(boolean fair) {
+        final ReentrantLock lock = new ReentrantLock(fair);
         try {
-            final ReentrantLock lock = new ReentrantLock(fair);
             assertFalse(lock.isLocked());
             lock.lock();
             assertTrue(lock.isLocked());
@@ -523,18 +523,18 @@ public class ReentrantLockTest extends J
     public void testAwaitNanos_Timeout()      { testAwaitNanos_Timeout(false); }
     public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
     public void testAwaitNanos_Timeout(boolean fair) {
+        final ReentrantLock lock = new ReentrantLock(fair);
+        final Condition c = lock.newCondition();
+        final long timeoutMillis = timeoutMillis();
+        final long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
+        lock.lock();
+        final long startTime = System.nanoTime();
         try {
-            final ReentrantLock lock = new ReentrantLock(fair);
-            final Condition c = lock.newCondition();
-            lock.lock();
-            long startTime = System.nanoTime();
-            long timeoutMillis = 10;
-            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
             long nanosRemaining = c.awaitNanos(timeoutNanos);
             assertTrue(nanosRemaining <= 0);
-            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-            lock.unlock();
         } catch (InterruptedException fail) { threadUnexpectedException(fail); }
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
+        lock.unlock();
     }
 
     /**
@@ -543,16 +543,16 @@ public class ReentrantLockTest extends J
     public void testAwait_Timeout()      { testAwait_Timeout(false); }
     public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
     public void testAwait_Timeout(boolean fair) {
+        final ReentrantLock lock = new ReentrantLock(fair);
+        final Condition c = lock.newCondition();
+        final long timeoutMillis = timeoutMillis();
+        lock.lock();
+        final long startTime = System.nanoTime();
         try {
-            final ReentrantLock lock = new ReentrantLock(fair);
-            final Condition c = lock.newCondition();
-            lock.lock();
-            long startTime = System.nanoTime();
-            long timeoutMillis = 10;
             assertFalse(c.await(timeoutMillis, MILLISECONDS));
-            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-            lock.unlock();
         } catch (InterruptedException fail) { threadUnexpectedException(fail); }
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
+        lock.unlock();
     }
 
     /**
@@ -561,15 +561,17 @@ public class ReentrantLockTest extends J
     public void testAwaitUntil_Timeout()      { testAwaitUntil_Timeout(false); }
     public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
     public void testAwaitUntil_Timeout(boolean fair) {
+        final ReentrantLock lock = new ReentrantLock(fair);
+        final Condition c = lock.newCondition();
+        lock.lock();
+        // We shouldn't assume that nanoTime and currentTimeMillis
+        // use the same time source, so don't use nanoTime here.
+        final java.util.Date delayedDate = delayedDate(timeoutMillis());
         try {
-            final ReentrantLock lock = new ReentrantLock(fair);
-            final Condition c = lock.newCondition();
-            lock.lock();
-            long startTime = System.nanoTime();
-            assertFalse(c.awaitUntil(delayedDate(timeoutMillis())));
-            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
-            lock.unlock();
+            assertFalse(c.awaitUntil(delayedDate));
         } catch (InterruptedException fail) { threadUnexpectedException(fail); }
+        assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
+        lock.unlock();
     }
 
     /**
@@ -883,7 +885,7 @@ public class ReentrantLockTest extends J
     public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
     public void testAwaitUninterruptibly(boolean fair) {
         final ReentrantLock lock = new ReentrantLock(fair);
-        final Condition c = lock.newCondition();
+        final Condition condition = lock.newCondition();
         final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
 
         Thread t1 = newStartedThread(new CheckedRunnable() {
@@ -892,7 +894,7 @@ public class ReentrantLockTest extends J
                 lock.lock();
                 pleaseInterrupt.countDown();
                 Thread.currentThread().interrupt();
-                c.awaitUninterruptibly();
+                condition.awaitUninterruptibly();
                 assertTrue(Thread.interrupted());
                 lock.unlock();
             }});
@@ -902,21 +904,20 @@ public class ReentrantLockTest extends J
                 // Interrupt during awaitUninterruptibly
                 lock.lock();
                 pleaseInterrupt.countDown();
-                c.awaitUninterruptibly();
+                condition.awaitUninterruptibly();
                 assertTrue(Thread.interrupted());
                 lock.unlock();
             }});
 
         await(pleaseInterrupt);
+        t2.interrupt();
         lock.lock();
         lock.unlock();
-        t2.interrupt();
-
-        assertThreadStaysAlive(t1);
-        assertTrue(t2.isAlive());
+        assertThreadBlocks(t1, Thread.State.WAITING);
+        assertThreadBlocks(t2, Thread.State.WAITING);
 
         lock.lock();
-        c.signalAll();
+        condition.signalAll();
         lock.unlock();
 
         awaitTermination(t1);
@@ -1098,7 +1099,7 @@ public class ReentrantLockTest extends J
     public void testSerialization()      { testSerialization(false); }
     public void testSerialization_fair() { testSerialization(true); }
     public void testSerialization(boolean fair) {
-        ReentrantLock lock = new ReentrantLock(fair);
+        final ReentrantLock lock = new ReentrantLock(fair);
         lock.lock();
 
         ReentrantLock clone = serialClone(lock);
@@ -1124,10 +1125,10 @@ public class ReentrantLockTest extends J
     public void testToString()      { testToString(false); }
     public void testToString_fair() { testToString(true); }
     public void testToString(boolean fair) {
-        ReentrantLock lock = new ReentrantLock(fair);
+        final ReentrantLock lock = new ReentrantLock(fair);
         assertTrue(lock.toString().contains("Unlocked"));
         lock.lock();
-        assertTrue(lock.toString().contains("Locked"));
+        assertTrue(lock.toString().contains("Locked by"));
         lock.unlock();
         assertTrue(lock.toString().contains("Unlocked"));
     }