--- jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java	2017/01/01 20:34:39	1.53
+++ jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java	2017/09/29 19:34:37	1.58
@@ -19,6 +19,7 @@ import junit.framework.AssertionFailedEr
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
+@SuppressWarnings("WaitNotInLoop") // we implement spurious-wakeup freedom
 public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
     public static void main(String[] args) {
         main(suite(), args);
@@ -33,6 +34,9 @@ public class AbstractQueuedSynchronizerT
      * methods/features of AbstractQueuedSynchronizer are tested via
      * other test classes, including those for ReentrantLock,
      * ReentrantReadWriteLock, and Semaphore.
+     *
+     * Unlike the javadoc sample, we don't track owner thread via
+     * AbstractOwnableSynchronizer methods.
      */
     static class Mutex extends AbstractQueuedSynchronizer {
         /** An eccentric value for locked synchronizer state. */
@@ -40,18 +44,19 @@ public class AbstractQueuedSynchronizerT
 
         static final int UNLOCKED = 0;
 
+        /** Owner thread is untracked, so this is really just isLocked(). */
         @Override public boolean isHeldExclusively() {
             int state = getState();
             assertTrue(state == UNLOCKED || state == LOCKED);
             return state == LOCKED;
         }
 
-        @Override public boolean tryAcquire(int acquires) {
+        @Override protected boolean tryAcquire(int acquires) {
             assertEquals(LOCKED, acquires);
             return compareAndSetState(UNLOCKED, LOCKED);
         }
 
-        @Override public boolean tryRelease(int releases) {
+        @Override protected boolean tryRelease(int releases) {
             if (getState() != LOCKED) throw new IllegalMonitorStateException();
             assertEquals(LOCKED, releases);
             setState(UNLOCKED);
@@ -82,13 +87,14 @@ public class AbstractQueuedSynchronizerT
             release(LOCKED);
         }
 
+        /** Faux-Implements Lock.newCondition(). */
         public ConditionObject newCondition() {
             return new ConditionObject();
         }
     }
 
     /**
-     * A simple latch class, to test shared mode.
+     * A minimal latch class, to test shared mode.
      */
     static class BooleanLatch extends AbstractQueuedSynchronizer {
         public boolean isSignalled() { return getState() != 0; }
@@ -968,30 +974,30 @@ public class AbstractQueuedSynchronizerT
      */
     public void testAwaitUninterruptibly() {
         final Mutex sync = new Mutex();
-        final ConditionObject c = sync.newCondition();
+        final ConditionObject condition = sync.newCondition();
         final BooleanLatch pleaseInterrupt = new BooleanLatch();
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() {
                 sync.acquire();
                 assertTrue(pleaseInterrupt.releaseShared(0));
-                c.awaitUninterruptibly();
+                condition.awaitUninterruptibly();
                 assertTrue(Thread.interrupted());
-                assertHasWaitersLocked(sync, c, NO_THREADS);
+                assertHasWaitersLocked(sync, condition, NO_THREADS);
                 sync.release();
             }});
 
         pleaseInterrupt.acquireShared(0);
         sync.acquire();
-        assertHasWaitersLocked(sync, c, t);
+        assertHasWaitersLocked(sync, condition, t);
         sync.release();
         t.interrupt();
-        assertHasWaitersUnlocked(sync, c, t);
-        assertThreadStaysAlive(t);
+        assertHasWaitersUnlocked(sync, condition, t);
+        assertThreadBlocks(t, Thread.State.WAITING);
         sync.acquire();
-        assertHasWaitersLocked(sync, c, t);
+        assertHasWaitersLocked(sync, condition, t);
         assertHasExclusiveQueuedThreads(sync, NO_THREADS);
-        c.signal();
-        assertHasWaitersLocked(sync, c, NO_THREADS);
+        condition.signal();
+        assertHasWaitersLocked(sync, condition, NO_THREADS);
         assertHasExclusiveQueuedThreads(sync, t);
         sync.release();
         awaitTermination(t);
@@ -1134,7 +1140,7 @@ public class AbstractQueuedSynchronizerT
 
         waitForQueuedThread(l, t);
         assertFalse(l.isSignalled());
-        assertThreadStaysAlive(t);
+        assertThreadBlocks(t, Thread.State.WAITING);
         assertHasSharedQueuedThreads(l, t);
         assertTrue(l.releaseShared(0));
         assertTrue(l.isSignalled());
@@ -1159,7 +1165,7 @@ public class AbstractQueuedSynchronizerT
 
         waitForQueuedThread(l, t);
         assertFalse(l.isSignalled());
-        assertThreadStaysAlive(t);
+        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
         assertTrue(l.releaseShared(0));
         assertTrue(l.isSignalled());
         awaitTermination(t);