--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2011/05/24 23:40:14	1.64
+++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java	2014/12/31 05:04:04	1.68
@@ -8,10 +8,11 @@
 
 import junit.framework.*;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.locks.*;
-import java.util.concurrent.*;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.concurrent.CountDownLatch;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.io.*;
 import java.util.*;
 
 public class ReentrantReadWriteLockTest extends JSR166TestCase {
@@ -84,7 +85,7 @@ public class ReentrantReadWriteLockTest
             Thread.yield();
         }
         assertTrue(t.isAlive());
-        assertTrue(lock.getOwner() != t);
+        assertNotSame(t, lock.getOwner());
     }
 
     /**
@@ -145,7 +146,7 @@ public class ReentrantReadWriteLockTest
         lock.writeLock().unlock();
     }
 
-    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
+    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
 
     /**
      * Awaits condition using the specified AwaitMethod.
@@ -1004,33 +1005,50 @@ public class ReentrantReadWriteLockTest
     }
 
     /**
-     * awaitUninterruptibly doesn't abort on interrupt
+     * awaitUninterruptibly is uninterruptible
      */
     public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
     public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
     public void testAwaitUninterruptibly(boolean fair) {
         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
         final Condition c = lock.writeLock().newCondition();
-        final CountDownLatch locked = new CountDownLatch(1);
-        Thread t = newStartedThread(new CheckedRunnable() {
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
+
+        Thread t1 = newStartedThread(new CheckedRunnable() {
             public void realRun() {
+                // Interrupt before awaitUninterruptibly
                 lock.writeLock().lock();
-                locked.countDown();
+                pleaseInterrupt.countDown();
+                Thread.currentThread().interrupt();
                 c.awaitUninterruptibly();
                 assertTrue(Thread.interrupted());
                 lock.writeLock().unlock();
             }});
 
-        await(locked);
+        Thread t2 = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                // Interrupt during awaitUninterruptibly
+                lock.writeLock().lock();
+                pleaseInterrupt.countDown();
+                c.awaitUninterruptibly();
+                assertTrue(Thread.interrupted());
+                lock.writeLock().unlock();
+            }});
+
+        await(pleaseInterrupt);
         lock.writeLock().lock();
         lock.writeLock().unlock();
-        t.interrupt();
-        long timeoutMillis = 10;
-        assertThreadStaysAlive(t, timeoutMillis);
+        t2.interrupt();
+
+        assertThreadStaysAlive(t1);
+        assertTrue(t2.isAlive());
+
         lock.writeLock().lock();
-        c.signal();
+        c.signalAll();
         lock.writeLock().unlock();
-        awaitTermination(t);
+
+        awaitTermination(t1);
+        awaitTermination(t2);
     }
 
     /**