--- jsr166/src/test/tck/LinkedTransferQueueTest.java	2015/10/18 04:48:32	1.66
+++ jsr166/src/test/tck/LinkedTransferQueueTest.java	2017/03/25 21:41:10	1.72
@@ -15,6 +15,7 @@ import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Queue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
@@ -24,14 +25,6 @@ import junit.framework.Test;
 
 @SuppressWarnings({"unchecked", "rawtypes"})
 public class LinkedTransferQueueTest extends JSR166TestCase {
-    static class Implementation implements CollectionImplementation {
-        public Class<?> klazz() { return LinkedTransferQueue.class; }
-        public Collection emptyCollection() { return new LinkedTransferQueue(); }
-        public Object makeElement(int i) { return i; }
-        public boolean isConcurrent() { return true; }
-        public boolean permitsNulls() { return false; }
-    }
-
     public static class Generic extends BlockingQueueTest {
         protected BlockingQueue emptyCollection() {
             return new LinkedTransferQueue();
@@ -43,6 +36,13 @@ public class LinkedTransferQueueTest ext
     }
 
     public static Test suite() {
+        class Implementation implements CollectionImplementation {
+            public Class<?> klazz() { return LinkedTransferQueue.class; }
+            public Collection emptyCollection() { return new LinkedTransferQueue(); }
+            public Object makeElement(int i) { return i; }
+            public boolean isConcurrent() { return true; }
+            public boolean permitsNulls() { return false; }
+        }
         return newTestSuite(LinkedTransferQueueTest.class,
                             new Generic().testSuite(),
                             CollectionTest.testSuite(new Implementation()));
@@ -183,7 +183,7 @@ public class LinkedTransferQueueTest ext
      * all elements successfully put are contained
      */
     public void testPut() {
-        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
+        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, q.size());
             q.put(i);
@@ -294,7 +294,7 @@ public class LinkedTransferQueueTest ext
                 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
             }});
 
-        aboutToWait.await();
+        await(aboutToWait);
         waitForThreadToEnterWaitState(t);
         t.interrupt();
         awaitTermination(t);
@@ -416,7 +416,7 @@ public class LinkedTransferQueueTest ext
      */
     public void testContainsAll() {
         LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
-        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
+        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
@@ -545,8 +545,7 @@ public class LinkedTransferQueueTest ext
      * iterator ordering is FIFO
      */
     public void testIteratorOrdering() {
-        final LinkedTransferQueue<Integer> q
-            = new LinkedTransferQueue<Integer>();
+        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
         assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
         q.add(one);
         q.add(two);
@@ -741,9 +740,11 @@ public class LinkedTransferQueueTest ext
             }});
 
         threadStarted.await();
-        waitForThreadToEnterWaitState(t);
-        assertEquals(1, q.getWaitingConsumerCount());
-        assertTrue(q.hasWaitingConsumer());
+        Callable<Boolean> oneConsumer
+            = new Callable<Boolean>() { public Boolean call() {
+                return q.hasWaitingConsumer()
+                && q.getWaitingConsumerCount() == 1; }};
+        waitForThreadToEnterWaitState(t, oneConsumer);
 
         assertTrue(q.offer(one));
         assertEquals(0, q.getWaitingConsumerCount());
@@ -765,11 +766,10 @@ public class LinkedTransferQueueTest ext
 
     /**
      * transfer waits until a poll occurs. The transfered element
-     * is returned by this associated poll.
+     * is returned by the associated poll.
      */
     public void testTransfer2() throws InterruptedException {
-        final LinkedTransferQueue<Integer> q
-            = new LinkedTransferQueue<Integer>();
+        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
         final CountDownLatch threadStarted = new CountDownLatch(1);
 
         Thread t = newStartedThread(new CheckedRunnable() {
@@ -780,8 +780,11 @@ public class LinkedTransferQueueTest ext
             }});
 
         threadStarted.await();
-        waitForThreadToEnterWaitState(t);
-        assertEquals(1, q.size());
+        Callable<Boolean> oneElement
+            = new Callable<Boolean>() { public Boolean call() {
+                return !q.isEmpty() && q.size() == 1; }};
+        waitForThreadToEnterWaitState(t, oneElement);
+
         assertSame(five, q.poll());
         checkEmpty(q);
         awaitTermination(t);
@@ -791,13 +794,12 @@ public class LinkedTransferQueueTest ext
      * transfer waits until a poll occurs, and then transfers in fifo order
      */
     public void testTransfer3() throws InterruptedException {
-        final LinkedTransferQueue<Integer> q
-            = new LinkedTransferQueue<Integer>();
+        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
 
         Thread first = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.transfer(four);
-                assertTrue(!q.contains(four));
+                assertFalse(q.contains(four));
                 assertEquals(1, q.size());
             }});
 
@@ -845,11 +847,10 @@ public class LinkedTransferQueueTest ext
 
     /**
      * transfer waits until a take occurs. The transfered element
-     * is returned by this associated take.
+     * is returned by the associated take.
      */
     public void testTransfer5() throws InterruptedException {
-        final LinkedTransferQueue<Integer> q
-            = new LinkedTransferQueue<Integer>();
+        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
 
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
@@ -1030,7 +1031,7 @@ public class LinkedTransferQueueTest ext
     }
 
     private LinkedTransferQueue<Integer> populatedQueue(int n) {
-        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
+        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
         checkEmpty(q);
         for (int i = 0; i < n; i++) {
             assertEquals(i, q.size());