--- jsr166/src/test/tck/LinkedTransferQueueTest.java	2009/08/02 12:31:24	1.6
+++ jsr166/src/test/tck/LinkedTransferQueueTest.java	2021/01/27 02:55:18	1.88
@@ -1,64 +1,83 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  * Other contributors include John Vint
  */
 
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.ConcurrentModificationException;
+import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.NoSuchElementException;
-import java.util.concurrent.*;
+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;
+import java.util.concurrent.LinkedTransferQueue;
+
 import junit.framework.Test;
-import junit.framework.TestSuite;
 
+@SuppressWarnings({"unchecked", "rawtypes"})
 public class LinkedTransferQueueTest extends JSR166TestCase {
+    public static class Generic extends BlockingQueueTest {
+        protected BlockingQueue emptyCollection() {
+            return new LinkedTransferQueue();
+        }
+    }
 
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
 
     public static Test suite() {
-        return new TestSuite(LinkedTransferQueueTest.class);
+        class Implementation implements CollectionImplementation {
+            public Class<?> klazz() { return LinkedTransferQueue.class; }
+            public Collection emptyCollection() { return new LinkedTransferQueue(); }
+            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
+            public boolean isConcurrent() { return true; }
+            public boolean permitsNulls() { return false; }
+        }
+        return newTestSuite(LinkedTransferQueueTest.class,
+                            new Generic().testSuite(),
+                            CollectionTest.testSuite(new Implementation()));
     }
 
     /**
-     * Constructor builds new queue with size being zero and empty being true
+     * Constructor builds new queue with size being zero and empty
+     * being true
      */
     public void testConstructor1() {
-        assertEquals(0, new LinkedTransferQueue().size());
+        mustEqual(0, new LinkedTransferQueue().size());
         assertTrue(new LinkedTransferQueue().isEmpty());
     }
 
     /**
-     * Initializing constructor with null collection throws NullPointerException
+     * Initializing constructor with null collection throws
+     * NullPointerException
      */
     public void testConstructor2() {
         try {
             new LinkedTransferQueue(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * Initializing from Collection of null elements throws NullPointerException
+     * Initializing from Collection of null elements throws
+     * NullPointerException
      */
     public void testConstructor3() {
+        Collection<Item> elements = Arrays.asList(new Item[SIZE]);
         try {
-            Integer[] ints = new Integer[SIZE];
-            LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
+            new LinkedTransferQueue(elements);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -66,84 +85,49 @@ public class LinkedTransferQueueTest ext
      * throws NullPointerException
      */
     public void testConstructor4() {
+        Item[] items = new Item[2];
+        items[0] = zero;
+        Collection<Item> elements = Arrays.asList(items);
         try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE - 1; ++i) {
-                ints[i] = i;
-            }
-            LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
+            new LinkedTransferQueue(elements);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Queue contains all elements of the collection it is initialized by
      */
     public void testConstructor5() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i) {
-                ints[i] = i;
-            }
-            LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
-            for (int i = 0; i < SIZE; ++i) {
-                assertEquals(ints[i], q.poll());
-            }
-        } finally {
+        Item[] items = defaultItems;
+        List<Item> intList = Arrays.asList(items);
+        LinkedTransferQueue<Item> q = new LinkedTransferQueue<>(intList);
+        mustEqual(q.size(), intList.size());
+        mustEqual(q.toString(), intList.toString());
+        assertTrue(Arrays.equals(q.toArray(),
+                                     intList.toArray()));
+        assertTrue(Arrays.equals(q.toArray(new Object[0]),
+                                 intList.toArray(new Object[0])));
+        assertTrue(Arrays.equals(q.toArray(new Object[SIZE]),
+                                 intList.toArray(new Object[SIZE])));
+        for (int i = 0; i < SIZE; ++i) {
+            mustEqual(items[i], q.poll());
         }
     }
 
     /**
-     * Remaining capacity never decrease nor increase on add or remove
+     * remainingCapacity() always returns Integer.MAX_VALUE
      */
     public void testRemainingCapacity() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+        BlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
-            assertEquals(SIZE - i, q.size());
-            q.remove();
+            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
+            mustEqual(SIZE - i, q.size());
+            mustEqual(i, q.remove());
         }
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
-            assertEquals(i, q.size());
-            q.add(i);
-        }
-    }
-
-    /**
-     * offer(null) throws NullPointerException
-     */
-    public void testOfferNull() {
-        try {
-            LinkedTransferQueue q = new LinkedTransferQueue();
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        }
-    }
-
-    /**
-     * add(null) throws NullPointerException
-     */
-    public void testAddNull() {
-        try {
-            LinkedTransferQueue q = new LinkedTransferQueue();
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        }
-    }
-
-    /**
-     * addAll(null) throws NullPointerException
-     */
-    public void testAddAll1() {
-        try {
-            LinkedTransferQueue q = new LinkedTransferQueue();
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {
+            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
+            mustEqual(i, q.size());
+            mustAdd(q, i);
         }
     }
 
@@ -151,170 +135,132 @@ public class LinkedTransferQueueTest ext
      * addAll(this) throws IllegalArgumentException
      */
     public void testAddAllSelf() {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         try {
-            LinkedTransferQueue q = populatedQueue(SIZE);
             q.addAll(q);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
-    }
-
-    /**
-     * addAll of a collection with null elements throws NullPointerException
-     */
-    public void testAddAll2() {
-        try {
-            LinkedTransferQueue q = new LinkedTransferQueue();
-            Integer[] ints = new Integer[SIZE];
-            q.addAll(Arrays.asList(ints));
-            shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
-     * addAll of a collection with any null elements throws NullPointerException after
-     * possibly adding some elements
+     * addAll of a collection with any null elements throws
+     * NullPointerException after possibly adding some elements
      */
     public void testAddAll3() {
+        LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        Item[] items = new Item[2]; items[0] = zero;
         try {
-            LinkedTransferQueue q = new LinkedTransferQueue();
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE - 1; ++i) {
-                ints[i] = i;
-            }
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(items));
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Queue contains all elements, in traversal order, of successful addAll
      */
     public void testAddAll5() {
-        Integer[] empty = new Integer[0];
-        Integer[] ints = new Integer[SIZE];
-        for (int i = 0; i < SIZE; ++i) {
-            ints[i] = i;
-        }
+        Item[] empty = new Item[0];
+        Item[] items = defaultItems;
         LinkedTransferQueue q = new LinkedTransferQueue();
         assertFalse(q.addAll(Arrays.asList(empty)));
-        assertTrue(q.addAll(Arrays.asList(ints)));
+        assertTrue(q.addAll(Arrays.asList(items)));
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(ints[i], q.poll());
+            mustEqual(items[i], q.poll());
         }
     }
 
     /**
-     * put(null) throws NullPointerException
-     */
-    public void testPutNull() throws InterruptedException {
-        try {
-            LinkedTransferQueue q = new LinkedTransferQueue();
-            q.put(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
      * all elements successfully put are contained
      */
     public void testPut() {
-        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
+        LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        Item[] items = defaultItems;
         for (int i = 0; i < SIZE; ++i) {
-            q.put(i);
-            assertTrue(q.contains(i));
+            mustEqual(i, q.size());
+            q.put(items[i]);
+            mustContain(q, items[i]);
         }
-        assertEquals(q.size(), SIZE);
     }
 
     /**
      * take retrieves elements in FIFO order
      */
     public void testTake() throws InterruptedException {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, (int) q.take());
+            mustEqual(i, q.take());
         }
     }
 
     /**
-     * take blocks interruptibly when empty
+     * take removes existing elements until empty, then blocks interruptibly
      */
-    public void testTakeFromEmpty() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        Thread t = new Thread(new Runnable() {
-            public void run() {
+    public void testBlockingTake() throws InterruptedException {
+        final BlockingQueue<Item> q = populatedQueue(SIZE);
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                for (int i = 0; i < SIZE; i++) mustEqual(i, q.take());
+
+                Thread.currentThread().interrupt();
                 try {
                     q.take();
-                    threadShouldThrow();
-                } catch (InterruptedException success) {
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }});
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
 
-    /**
-     * Take removes existing elements until empty, then blocks interruptibly
-     */
-    public void testBlockingTake() throws InterruptedException {
-        Thread t = new Thread(new Runnable() {
-            public void run() {
+                pleaseInterrupt.countDown();
                 try {
-                    LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
-                    for (int i = 0; i < SIZE; ++i) {
-                        threadAssertEquals(i, (int) q.take());
-                    }
                     q.take();
-                    threadShouldThrow();
-                } catch (InterruptedException success) {
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
             }});
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+
+        await(pleaseInterrupt);
+        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
         t.interrupt();
-        t.join();
+        awaitTermination(t);
     }
 
     /**
      * poll succeeds unless empty
      */
-    public void testPoll() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+    public void testPoll() throws InterruptedException {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, (int) q.poll());
+            mustEqual(i, q.poll());
         }
         assertNull(q.poll());
+        checkEmpty(q);
     }
 
     /**
-     * timed pool with zero timeout succeeds when non-empty, else times out
+     * timed poll with zero timeout succeeds when non-empty, else times out
      */
     public void testTimedPoll0() throws InterruptedException {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, (int) q.poll(0, TimeUnit.MILLISECONDS));
+            mustEqual(i, q.poll(0, MILLISECONDS));
         }
-        assertNull(q.poll(0, TimeUnit.MILLISECONDS));
+        assertNull(q.poll(0, MILLISECONDS));
+        checkEmpty(q);
     }
 
     /**
-     * timed pool with nonzero timeout succeeds when non-empty, else times out
+     * timed poll with nonzero timeout succeeds when non-empty, else times out
      */
     public void testTimedPoll() throws InterruptedException {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-        }
-        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+        long startTime = System.nanoTime();
+        for (int i = 0; i < SIZE; ++i)
+            mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
+        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
+
+        startTime = System.nanoTime();
+        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
+        checkEmpty(q);
     }
 
     /**
@@ -322,171 +268,165 @@ public class LinkedTransferQueueTest ext
      * returning timeout status
      */
     public void testInterruptedTimedPoll() throws InterruptedException {
-        Thread t = new Thread(new Runnable() {
-            public void run() {
+        final BlockingQueue<Item> q = populatedQueue(SIZE);
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                for (int i = 0; i < SIZE; i++)
+                    mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
+
+                Thread.currentThread().interrupt();
+                try {
+                    q.poll(randomTimeout(), randomTimeUnit());
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
+
+                pleaseInterrupt.countDown();
                 try {
-                    LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
-                    for (int i = 0; i < SIZE; ++i) {
-                        threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-                    }
-                    threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-                } catch (InterruptedException success) {
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
+                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
             }});
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+
+        await(pleaseInterrupt);
+        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
         t.interrupt();
-        t.join();
+        awaitTermination(t);
+        checkEmpty(q);
     }
 
     /**
-     * timed poll before a delayed offer fails; after offer succeeds;
-     * on interruption throws
+     * timed poll after thread interrupted throws InterruptedException
+     * instead of returning timeout status
      */
-    public void testTimedPollWithOffer() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        Thread t = new Thread(new Runnable() {
-            public void run() {
+    public void testTimedPollAfterInterrupt() throws InterruptedException {
+        final BlockingQueue<Item> q = populatedQueue(SIZE);
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                Thread.currentThread().interrupt();
+                for (int i = 0; i < SIZE; ++i)
+                    mustEqual(i, q.poll(randomTimeout(), randomTimeUnit()));
                 try {
-                    threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-                    q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
-                    q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
-                    threadShouldThrow();
-                } catch (InterruptedException success) {
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
+                    q.poll(randomTimeout(), randomTimeUnit());
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
             }});
-        t.start();
-        Thread.sleep(SMALL_DELAY_MS);
-        assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-        t.interrupt();
-        t.join();
+
+        awaitTermination(t);
+        checkEmpty(q);
     }
 
     /**
      * peek returns next element, or null if empty
      */
-    public void testPeek() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+    public void testPeek() throws InterruptedException {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, (int) q.peek());
-            assertEquals(i, (int) q.poll());
+            mustEqual(i, q.peek());
+            mustEqual(i, q.poll());
             assertTrue(q.peek() == null ||
-                       i != (int) q.peek());
+                       i != q.peek().value);
         }
         assertNull(q.peek());
+        checkEmpty(q);
     }
 
     /**
      * element returns next element, or throws NoSuchElementException if empty
      */
-    public void testElement() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+    public void testElement() throws InterruptedException {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, (int) q.element());
-            assertEquals(i, (int) q.poll());
+            mustEqual(i, q.element());
+            mustEqual(i, q.poll());
         }
         try {
             q.element();
             shouldThrow();
-        } catch (NoSuchElementException success) {
-        }
+        } catch (NoSuchElementException success) {}
+        checkEmpty(q);
     }
 
     /**
      * remove removes next element, or throws NoSuchElementException if empty
      */
-    public void testRemove() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+    public void testRemove() throws InterruptedException {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, (int) q.remove());
+            mustEqual(i, q.remove());
         }
         try {
             q.remove();
             shouldThrow();
-        } catch (NoSuchElementException success) {
-        }
-    }
-
-    /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        for (int i = 1; i < SIZE; i += 2) {
-            assertTrue(q.remove(i));
-        }
-        for (int i = 0; i < SIZE; i += 2) {
-            assertTrue(q.remove(i));
-            assertFalse(q.remove(i + 1));
-        }
-        assertTrue(q.isEmpty());
+        } catch (NoSuchElementException success) {}
+        checkEmpty(q);
     }
 
     /**
      * An add following remove(x) succeeds
      */
     public void testRemoveElementAndAdd() throws InterruptedException {
-        LinkedTransferQueue q = new LinkedTransferQueue();
-        assertTrue(q.add(one));
-        assertTrue(q.add(two));
-        assertTrue(q.remove(one));
-        assertTrue(q.remove(two));
-        assertTrue(q.add(three));
-        assertTrue(q.take() != null);
+        LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        mustAdd(q, one);
+        mustAdd(q, two);
+        mustRemove(q, one);
+        mustRemove(q, two);
+        mustAdd(q, three);
+        mustEqual(q.take(), three);
     }
 
     /**
      * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertTrue(q.contains(i));
-            assertEquals(i, (int) q.poll());
-            assertFalse(q.contains(i));
+            mustContain(q, i);
+            mustEqual(i, q.poll());
+            mustNotContain(q, i);
         }
     }
 
     /**
      * clear removes all elements
      */
-    public void testClear() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
+    public void testClear() throws InterruptedException {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         q.clear();
-        assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
+        checkEmpty(q);
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
         q.add(one);
         assertFalse(q.isEmpty());
-        assertTrue(q.contains(one));
+        mustEqual(1, q.size());
+        mustContain(q, one);
         q.clear();
-        assertTrue(q.isEmpty());
+        checkEmpty(q);
     }
 
     /**
      * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
-        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> p = new LinkedTransferQueue<>();
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
-            p.add(i);
+            mustAdd(p, i);
         }
         assertTrue(p.containsAll(q));
     }
 
     /**
-     * retainAll(c) retains only those elements of c and reports true if changed
+     * retainAll(c) retains only those elements of c and reports true
+     * if changed
      */
     public void testRetainAll() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        LinkedTransferQueue p = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> p = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             boolean changed = q.retainAll(p);
             if (i == 0) {
@@ -495,100 +435,106 @@ public class LinkedTransferQueueTest ext
                 assertTrue(changed);
             }
             assertTrue(q.containsAll(p));
-            assertEquals(SIZE - i, q.size());
+            mustEqual(SIZE - i, q.size());
             p.remove();
         }
     }
 
     /**
-     * removeAll(c) removes only those elements of c and reports true if changed
+     * removeAll(c) removes only those elements of c and reports true
+     * if changed
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
-            LinkedTransferQueue q = populatedQueue(SIZE);
-            LinkedTransferQueue p = populatedQueue(i);
+            LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+            LinkedTransferQueue<Item> p = populatedQueue(i);
             assertTrue(q.removeAll(p));
-            assertEquals(SIZE - i, q.size());
+            mustEqual(SIZE - i, q.size());
             for (int j = 0; j < i; ++j) {
-                assertFalse(q.contains(p.remove()));
+                mustNotContain(q, p.remove());
             }
         }
     }
 
     /**
-     * toArray contains all elements
+     * toArray() contains all elements in FIFO order
      */
-    public void testToArray() throws InterruptedException {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++) {
-            assertEquals(o[i], q.take());
-        }
+    public void testToArray() {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
-     * toArray(a) contains all elements
+     * toArray(a) contains all elements in FIFO order
      */
-    public void testToArray2() throws InterruptedException {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
-        Integer[] ints = new Integer[SIZE];
-        ints = q.toArray(ints);
-        for (int i = 0; i < ints.length; i++) {
-            assertEquals(ints[i], q.take());
-        }
+    public void testToArray2() {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+        Item[] items = new Item[SIZE];
+        Item[] array = q.toArray(items);
+        assertSame(items, array);
+        for (Item o : items)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
-     * toArray(null) throws NullPointerException
+     * toArray(incompatible array type) throws ArrayStoreException
      */
-    public void testToArray_BadArg() {
+    @SuppressWarnings("CollectionToArraySafeParameter")
+    public void testToArray_incompatibleArrayType() {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         try {
-            LinkedTransferQueue q = populatedQueue(SIZE);
-            Object o[] = q.toArray(null);
+            q.toArray(new String[10]);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (ArrayStoreException success) {}
     }
 
     /**
-     * toArray with incompatible array type throws CCE
+     * iterator iterates through all elements
      */
-    public void testToArray1_BadArg() {
-        try {
-            LinkedTransferQueue q = populatedQueue(SIZE);
-            Object o[] = q.toArray(new String[10]);
-            shouldThrow();
-        } catch (ArrayStoreException success) {
-        }
+    public void testIterator() throws InterruptedException {
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+        Iterator<? extends Item> it = q.iterator();
+        int i;
+        for (i = 0; it.hasNext(); i++)
+            mustContain(q, it.next());
+        mustEqual(i, SIZE);
+        assertIteratorExhausted(it);
+
+        it = q.iterator();
+        for (i = 0; it.hasNext(); i++)
+            mustEqual(it.next(), q.take());
+        mustEqual(i, SIZE);
+        assertIteratorExhausted(it);
     }
 
     /**
-     * iterator iterates through all elements
+     * iterator of empty collection has no elements
      */
-    public void testIterator() throws InterruptedException {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        Iterator it = q.iterator();
-        while (it.hasNext()) {
-            assertEquals(it.next(), q.take());
-        }
+    public void testEmptyIterator() {
+        assertIteratorExhausted(new LinkedTransferQueue().iterator());
     }
 
     /**
-     * iterator.remove removes current element
+     * iterator.remove() removes current element
      */
     public void testIteratorRemove() {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
         q.add(two);
         q.add(one);
         q.add(three);
 
-        Iterator it = q.iterator();
+        Iterator<? extends Item> it = q.iterator();
         it.next();
         it.remove();
 
         it = q.iterator();
-        assertEquals(it.next(), one);
-        assertEquals(it.next(), three);
+        assertSame(it.next(), one);
+        assertSame(it.next(), three);
         assertFalse(it.hasNext());
     }
 
@@ -596,42 +542,42 @@ public class LinkedTransferQueueTest ext
      * iterator ordering is FIFO
      */
     public void testIteratorOrdering() {
-        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
-        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
         q.add(one);
         q.add(two);
         q.add(three);
-        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
         int k = 0;
-        for (Integer n : q) {
-            assertEquals(++k, (int) n);
+        for (Item n : q) {
+            mustEqual(++k, n);
         }
-        assertEquals(3, k);
+        mustEqual(3, k);
     }
 
     /**
      * Modifications do not cause iterators to fail
      */
     public void testWeaklyConsistentIteration() {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
         q.add(one);
         q.add(two);
         q.add(three);
-        for (Iterator it = q.iterator(); it.hasNext();) {
+        for (Iterator<? extends Item> it = q.iterator(); it.hasNext();) {
             q.remove();
             it.next();
         }
-        assertEquals(0, q.size());
+        mustEqual(0, q.size());
     }
 
     /**
      * toString contains toStrings of elements
      */
     public void testToString() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         String s = q.toString();
         for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
+            assertTrue(s.contains(String.valueOf(i)));
         }
     }
 
@@ -639,221 +585,169 @@ public class LinkedTransferQueueTest ext
      * offer transfers elements across Executor tasks
      */
     public void testOfferInExecutor() {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        q.add(one);
-        q.add(two);
-        ExecutorService executor = Executors.newFixedThreadPool(2);
-        executor.execute(new Runnable() {
-            public void run() {
-                try {
-                    threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }});
-
-        executor.execute(new Runnable() {
-            public void run() {
-                try {
-                    Thread.sleep(SMALL_DELAY_MS);
-                    threadAssertEquals(one, q.take());
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }});
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
+        final ExecutorService executor = Executors.newFixedThreadPool(2);
+        try (PoolCleaner cleaner = cleaner(executor)) {
+
+            executor.execute(new CheckedRunnable() {
+                public void realRun() throws InterruptedException {
+                    threadsStarted.await();
+                    long startTime = System.nanoTime();
+                    assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
+                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
+                }});
 
-        joinPool(executor);
+            executor.execute(new CheckedRunnable() {
+                public void realRun() throws InterruptedException {
+                    threadsStarted.await();
+                    assertSame(one, q.take());
+                    checkEmpty(q);
+                }});
+        }
     }
 
     /**
-     * poll retrieves elements across Executor threads
+     * timed poll retrieves elements across Executor threads
      */
     public void testPollInExecutor() {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        ExecutorService executor = Executors.newFixedThreadPool(2);
-        executor.execute(new Runnable() {
-            public void run() {
-                try {
-                    threadAssertNull(q.poll());
-                    threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
-                    threadAssertTrue(q.isEmpty());
-                } catch (Throwable  ex) {
-                    threadUnexpectedException(ex);
-                }
-            }});
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
+        final ExecutorService executor = Executors.newFixedThreadPool(2);
+        try (PoolCleaner cleaner = cleaner(executor)) {
+
+            executor.execute(new CheckedRunnable() {
+                public void realRun() throws InterruptedException {
+                    assertNull(q.poll());
+                    threadsStarted.await();
+                    long startTime = System.nanoTime();
+                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
+                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
+                    checkEmpty(q);
+                }});
 
-        executor.execute(new Runnable() {
-            public void run() {
-                try {
-                    Thread.sleep(SMALL_DELAY_MS);
+            executor.execute(new CheckedRunnable() {
+                public void realRun() throws InterruptedException {
+                    threadsStarted.await();
                     q.put(one);
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }});
-
-        joinPool(executor);
-    }
-
-    /**
-     * A deserialized serialized queue has same elements in same order
-     */
-    public void testSerialization() throws Exception {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-
-        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
-        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
-        out.writeObject(q);
-        out.close();
-
-        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
-        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
-        LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
-
-        assertEquals(q.size(), r.size());
-        while (!q.isEmpty()) {
-            assertEquals(q.remove(), r.remove());
+                }});
         }
     }
 
     /**
-     * drainTo(null) throws NullPointerException
+     * A deserialized/reserialized queue has same elements in same order
      */
-    public void testDrainToNull() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        }
-    }
+    public void testSerialization() throws Exception {
+        Queue<Item> x = populatedQueue(SIZE);
+        Queue<Item> y = serialClone(x);
 
-    /**
-     * drainTo(this) throws IllegalArgumentException
-     */
-    public void testDrainToSelf() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {
+        assertNotSame(y, x);
+        mustEqual(x.size(), y.size());
+        mustEqual(x.toString(), y.toString());
+        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
+        while (!x.isEmpty()) {
+            assertFalse(y.isEmpty());
+            mustEqual(x.remove(), y.remove());
         }
+        assertTrue(y.isEmpty());
     }
 
     /**
      * drainTo(c) empties queue into another collection c
      */
     public void testDrainTo() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
+        LinkedTransferQueue<Item> q = populatedQueue(SIZE);
         ArrayList l = new ArrayList();
         q.drainTo(l);
-        assertEquals(q.size(), 0);
-        assertEquals(l.size(), SIZE);
+        mustEqual(0, q.size());
+        mustEqual(SIZE, l.size());
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(l.get(i), i);
+            mustEqual(i, l.get(i));
         }
         q.add(zero);
         q.add(one);
         assertFalse(q.isEmpty());
-        assertTrue(q.contains(zero));
-        assertTrue(q.contains(one));
+        mustContain(q, zero);
+        mustContain(q, one);
         l.clear();
         q.drainTo(l);
-        assertEquals(q.size(), 0);
-        assertEquals(l.size(), 2);
+        mustEqual(0, q.size());
+        mustEqual(2, l.size());
         for (int i = 0; i < 2; ++i) {
-            assertEquals(l.get(i), i);
+            mustEqual(i, l.get(i));
         }
     }
 
     /**
-     * drainTo empties full queue, unblocking a waiting put.
+     * drainTo(c) empties full queue, unblocking a waiting put.
      */
     public void testDrainToWithActivePut() throws InterruptedException {
-        final LinkedTransferQueue q = populatedQueue(SIZE);
-        Thread t = new Thread(new Runnable() {
-            public void run() {
-                try {
-                    q.put(SIZE + 1);
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
+        final LinkedTransferQueue<Item> q = populatedQueue(SIZE);
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                q.put(new Item(SIZE + 1));
             }});
-        t.start();
         ArrayList l = new ArrayList();
         q.drainTo(l);
         assertTrue(l.size() >= SIZE);
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(l.get(i), i);
-        }
-        t.join();
+        for (int i = 0; i < SIZE; ++i)
+            mustEqual(i, l.get(i));
+        awaitTermination(t);
         assertTrue(q.size() + l.size() >= SIZE);
     }
 
     /**
-     * drainTo(null, n) throws NullPointerException
-     */
-    public void testDrainToNullN() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null, 0);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        }
-    }
-
-    /**
-     * drainTo(this, n) throws IllegalArgumentException
-     */
-    public void testDrainToSelfN() {
-        LinkedTransferQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q, 0);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
-    }
-
-    /**
-     * drainTo(c, n) empties first max {n, size} elements of queue into c
+     * drainTo(c, n) empties first min(n, size) elements of queue into c
      */
     public void testDrainToN() {
-        LinkedTransferQueue q = new LinkedTransferQueue();
+        LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
         for (int i = 0; i < SIZE + 2; ++i) {
             for (int j = 0; j < SIZE; j++) {
-                assertTrue(q.offer(j));
+                mustOffer(q, j);
             }
             ArrayList l = new ArrayList();
             q.drainTo(l, i);
             int k = (i < SIZE) ? i : SIZE;
-            assertEquals(l.size(), k);
-            assertEquals(q.size(), SIZE - k);
-            for (int j = 0; j < k; ++j) {
-                assertEquals(l.get(j), j);
-            }
-            while (q.poll() != null)
-                ;
+            mustEqual(k, l.size());
+            mustEqual(SIZE - k, q.size());
+            for (int j = 0; j < k; ++j)
+                mustEqual(j, l.get(j));
+            do {} while (q.poll() != null);
         }
     }
 
     /**
-     * poll and take decrement the waiting consumer count
+     * timed poll() or take() increments the waiting consumer count;
+     * offer(e) decrements the waiting consumer count
      */
     public void testWaitingConsumer() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        final ConsumerObserver waiting = new ConsumerObserver();
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    threadAssertTrue(q.hasWaitingConsumer());
-                    waiting.setWaitingConsumer(q.getWaitingConsumerCount());
-                    threadAssertTrue(q.offer(new Object()));
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
-        assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
-        assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        mustEqual(0, q.getWaitingConsumerCount());
+        assertFalse(q.hasWaitingConsumer());
+        final CountDownLatch threadStarted = new CountDownLatch(1);
+
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                threadStarted.countDown();
+                long startTime = System.nanoTime();
+                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
+                mustEqual(0, q.getWaitingConsumerCount());
+                assertFalse(q.hasWaitingConsumer());
+                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
+            }});
+
+        threadStarted.await();
+        Callable<Boolean> oneConsumer = new Callable<>() { 
+            public Boolean call() {
+                return q.hasWaitingConsumer()
+                && q.getWaitingConsumerCount() == 1; }};
+        waitForThreadToEnterWaitState(t, oneConsumer);
+
+        assertTrue(q.offer(one));
+        mustEqual(0, q.getWaitingConsumerCount());
+        assertFalse(q.hasWaitingConsumer());
+
+        awaitTermination(t);
     }
 
     /**
@@ -861,81 +755,68 @@ public class LinkedTransferQueueTest ext
      */
     public void testTransfer1() throws InterruptedException {
         try {
-            LinkedTransferQueue q = new LinkedTransferQueue();
+            LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
             q.transfer(null);
             shouldThrow();
-        } catch (NullPointerException ex) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * transfer waits until a poll occurs. The transfered element
-     * is returned by this associated poll.
+     * transfer waits until a poll occurs. The transferred element
+     * is returned by the associated poll.
      */
     public void testTransfer2() throws InterruptedException {
-        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        final CountDownLatch threadStarted = new CountDownLatch(1);
 
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    q.transfer(SIZE);
-                    threadAssertTrue(q.isEmpty());
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
-
-        Thread.sleep(SHORT_DELAY_MS);
-        assertEquals(1, q.size());
-        assertEquals(SIZE, (int) q.poll());
-        assertTrue(q.isEmpty());
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                threadStarted.countDown();
+                q.transfer(five);
+                checkEmpty(q);
+            }});
+
+        threadStarted.await();
+        Callable<Boolean> oneElement = new Callable<>() { 
+            public Boolean call() {
+                return !q.isEmpty() && q.size() == 1; }};
+        waitForThreadToEnterWaitState(t, oneElement);
+
+        assertSame(five, q.poll());
+        checkEmpty(q);
+        awaitTermination(t);
     }
 
     /**
      * 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<Item> q = new LinkedTransferQueue<>();
 
-        Thread first =
-            new Thread(new Runnable() {
-                public void run() {
-                    try {
-                        Integer i = SIZE + 1;
-                        q.transfer(i);
-                        threadAssertTrue(!q.contains(i));
-                        threadAssertEquals(1, q.size());
-                    } catch (Throwable ex) {
-                        threadUnexpectedException(ex);
-                    }
-                }});
-        first.start();
+        Thread first = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                q.transfer(four);
+                mustNotContain(q, four);
+                mustEqual(1, q.size());
+            }});
 
-        Thread interruptedThread =
-            new Thread(new Runnable() {
-                public void run() {
-                    try {
-                        while (q.size() == 0)
-                            Thread.yield();
-                        q.transfer(SIZE);
-                        threadShouldThrow();
-                    } catch (InterruptedException success) {
-                    } catch (Throwable ex) {
-                        threadUnexpectedException(ex);
-                    }
+        Thread interruptedThread = newStartedThread(
+            new CheckedInterruptedRunnable() {
+                public void realRun() throws InterruptedException {
+                    while (q.isEmpty())
+                        Thread.yield();
+                    q.transfer(five);
                 }});
-        interruptedThread.start();
 
         while (q.size() < 2)
             Thread.yield();
-        assertEquals(2, q.size());
-        assertEquals(SIZE + 1, (int) q.poll());
+        mustEqual(2, q.size());
+        assertSame(four, q.poll());
         first.join();
-        assertEquals(1, q.size());
+        mustEqual(1, q.size());
         interruptedThread.interrupt();
         interruptedThread.join();
-        assertEquals(0, q.size());
-        assertTrue(q.isEmpty());
+        checkEmpty(q);
     }
 
     /**
@@ -943,66 +824,66 @@ public class LinkedTransferQueueTest ext
      * thread returns the element
      */
     public void testTransfer4() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    q.transfer(four);
-                    threadAssertFalse(q.contains(four));
-                    threadAssertEquals(three, q.poll());
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
-        Thread.sleep(MEDIUM_DELAY_MS);
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                q.transfer(four);
+                mustNotContain(q, four);
+                assertSame(three, q.poll());
+            }});
+
+        while (q.isEmpty())
+            Thread.yield();
+        assertFalse(q.isEmpty());
+        mustEqual(1, q.size());
         assertTrue(q.offer(three));
-        assertEquals(four, q.poll());
+        assertSame(four, q.poll());
+        awaitTermination(t);
     }
 
     /**
-     * transfer waits until a take occurs. The transfered element
-     * is returned by this associated take.
+     * transfer waits until a take occurs. The transferred element
+     * is returned by the associated take.
      */
     public void testTransfer5() throws InterruptedException {
-        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
 
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    q.transfer(SIZE);
-                    threadAssertTrue(q.isEmpty());
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                q.transfer(four);
+                checkEmpty(q);
+            }});
 
-        Thread.sleep(SHORT_DELAY_MS);
-        assertEquals(SIZE, (int) q.take());
-        assertTrue(q.isEmpty());
+        while (q.isEmpty())
+            Thread.yield();
+        assertFalse(q.isEmpty());
+        mustEqual(1, q.size());
+        assertSame(four, q.take());
+        checkEmpty(q);
+        awaitTermination(t);
     }
 
     /**
      * tryTransfer(null) throws NullPointerException
      */
     public void testTryTransfer1() {
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
         try {
-            final LinkedTransferQueue q = new LinkedTransferQueue();
             q.tryTransfer(null);
-            this.shouldThrow();
-        } catch (NullPointerException ex) {
-        }
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
      * tryTransfer returns false and does not enqueue if there are no
      * consumers waiting to poll or take.
      */
-    public void testTryTransfer2() {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
+    public void testTryTransfer2() throws InterruptedException {
+        final LinkedTransferQueue<Object> q = new LinkedTransferQueue<>();
         assertFalse(q.tryTransfer(new Object()));
         assertFalse(q.hasWaitingConsumer());
-        assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
+        checkEmpty(q);
     }
 
     /**
@@ -1011,22 +892,22 @@ public class LinkedTransferQueueTest ext
      */
     public void testTryTransfer3() throws InterruptedException {
         final Object hotPotato = new Object();
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    while (! q.hasWaitingConsumer())
-                        Thread.yield();
-                    threadAssertTrue(q.hasWaitingConsumer());
-                    threadAssertTrue(q.isEmpty());
-                    threadAssertTrue(q.size() == 0);
-                    threadAssertTrue(q.tryTransfer(hotPotato));
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
-        assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) == hotPotato);
-        assertTrue(q.isEmpty());
+        final LinkedTransferQueue<Object> q = new LinkedTransferQueue<>();
+
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                while (! q.hasWaitingConsumer())
+                    Thread.yield();
+                assertTrue(q.hasWaitingConsumer());
+                checkEmpty(q);
+                assertTrue(q.tryTransfer(hotPotato));
+            }});
+
+        long startTime = System.nanoTime();
+        assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
+        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
+        checkEmpty(q);
+        awaitTermination(t);
     }
 
     /**
@@ -1035,60 +916,71 @@ public class LinkedTransferQueueTest ext
      */
     public void testTryTransfer4() throws InterruptedException {
         final Object hotPotato = new Object();
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    while (! q.hasWaitingConsumer())
-                        Thread.yield();
-                    threadAssertTrue(q.hasWaitingConsumer());
-                    threadAssertTrue(q.isEmpty());
-                    threadAssertTrue(q.size() == 0);
-                    threadAssertTrue(q.tryTransfer(hotPotato));
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
-        assertTrue(q.take() == hotPotato);
-        assertTrue(q.isEmpty());
+        final LinkedTransferQueue<Object> q = new LinkedTransferQueue<>();
+
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() {
+                while (! q.hasWaitingConsumer())
+                    Thread.yield();
+                assertTrue(q.hasWaitingConsumer());
+                checkEmpty(q);
+                assertTrue(q.tryTransfer(hotPotato));
+            }});
+
+        assertSame(q.take(), hotPotato);
+        checkEmpty(q);
+        awaitTermination(t);
     }
 
     /**
-     * tryTransfer waits the amount given if interrupted, and
-     * throws interrupted exception
+     * tryTransfer blocks interruptibly if no takers
      */
     public void testTryTransfer5() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        Thread toInterrupt = new Thread(new Runnable() {
-            public void run() {
+        final LinkedTransferQueue<Object> q = new LinkedTransferQueue<>();
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
+        assertTrue(q.isEmpty());
+
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                Thread.currentThread().interrupt();
                 try {
-                    q.tryTransfer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
-                    threadShouldThrow();
-                } catch (InterruptedException success) {
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
+                    q.tryTransfer(new Object(), randomTimeout(), randomTimeUnit());
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
+
+                pleaseInterrupt.countDown();
+                try {
+                    q.tryTransfer(new Object(), LONGER_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
             }});
-        toInterrupt.start();
-        Thread.sleep(SMALL_DELAY_MS);
-        toInterrupt.interrupt();
+
+        await(pleaseInterrupt);
+        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
+        t.interrupt();
+        awaitTermination(t);
+        checkEmpty(q);
     }
 
     /**
-     * tryTransfer gives up after the timeout and return false
+     * tryTransfer gives up after the timeout and returns false
      */
     public void testTryTransfer6() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    threadAssertFalse(q.tryTransfer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
-        Thread.sleep(LONG_DELAY_MS);
-        assertTrue(q.isEmpty());
+        final LinkedTransferQueue<Object> q = new LinkedTransferQueue<>();
+
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                long startTime = System.nanoTime();
+                assertFalse(q.tryTransfer(new Object(),
+                                          timeoutMillis(), MILLISECONDS));
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
+                checkEmpty(q);
+            }});
+
+        awaitTermination(t);
+        checkEmpty(q);
     }
 
     /**
@@ -1096,64 +988,67 @@ public class LinkedTransferQueueTest ext
      * before transfering to a poll or take
      */
     public void testTryTransfer7() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
         assertTrue(q.offer(four));
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    threadAssertTrue(q.tryTransfer(five, LONG_DELAY_MS, TimeUnit.MILLISECONDS));
-                    threadAssertTrue(q.isEmpty());
-                } catch (Throwable ex) {
-                    threadUnexpectedException(ex);
-                }
-            }}).start();
-        Thread.sleep(SHORT_DELAY_MS);
-        assertEquals(2, q.size());
-        assertEquals(four, q.poll());
-        assertEquals(five, q.poll());
-        assertTrue(q.isEmpty());
+
+        Thread t = newStartedThread(new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                long startTime = System.nanoTime();
+                assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
+                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
+                checkEmpty(q);
+            }});
+
+        while (q.size() != 2)
+            Thread.yield();
+        mustEqual(2, q.size());
+        assertSame(four, q.poll());
+        assertSame(five, q.poll());
+        checkEmpty(q);
+        awaitTermination(t);
     }
 
     /**
-     * tryTransfer attempts to enqueue into the q and fails returning
-     * false not enqueueing and the successive poll is null
+     * tryTransfer attempts to enqueue into the queue and fails
+     * returning false not enqueueing and the successive poll is null
      */
     public void testTryTransfer8() throws InterruptedException {
-        final LinkedTransferQueue q = new LinkedTransferQueue();
+        final LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
         assertTrue(q.offer(four));
-        assertEquals(1, q.size());
-        assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
-        assertEquals(1, q.size());
-        assertEquals(four, q.poll());
-        threadAssertTrue(q.isEmpty());
+        mustEqual(1, q.size());
+        long startTime = System.nanoTime();
+        assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
+        mustEqual(1, q.size());
+        assertSame(four, q.poll());
         assertNull(q.poll());
+        checkEmpty(q);
     }
 
-    private LinkedTransferQueue<Integer> populatedQueue(int n) {
-        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
-        assertTrue(q.isEmpty());
+    private LinkedTransferQueue<Item> populatedQueue(int n) {
+        LinkedTransferQueue<Item> q = new LinkedTransferQueue<>();
+        checkEmpty(q);
         for (int i = 0; i < n; i++) {
-            assertEquals(i, q.size());
-            assertTrue(q.offer(i));
-            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
+            mustEqual(i, q.size());
+            mustOffer(q, i);
+            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
         }
         assertFalse(q.isEmpty());
         return q;
     }
 
-    private static class ConsumerObserver {
-
-        private int waitingConsumers;
-
-        private ConsumerObserver() {
-        }
-
-        private void setWaitingConsumer(int i) {
-            this.waitingConsumers = i;
-        }
-
-        private int getWaitingConsumers() {
-            return waitingConsumers;
+    /**
+     * remove(null), contains(null) always return false
+     */
+    public void testNeverContainsNull() {
+        Collection<?>[] qs = {
+            new LinkedTransferQueue<>(),
+            populatedQueue(2),
+        };
+
+        for (Collection<?> q : qs) {
+            assertFalse(q.contains(null));
+            assertFalse(q.remove(null));
         }
     }
 }