--- jsr166/src/test/tck/DelayQueueTest.java	2009/12/23 00:47:16	1.30
+++ jsr166/src/test/tck/DelayQueueTest.java	2021/01/27 02:55:18	1.96
@@ -1,95 +1,102 @@
 /*
  * 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 Andrew Wright, Jeffrey Hayes,
  * Pat Fisher, Mike Judd.
  */
 
-import junit.framework.*;
-import java.util.*;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.concurrent.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.DelayQueue;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import junit.framework.Test;
 
 public class DelayQueueTest extends JSR166TestCase {
+
+    public static class Generic extends BlockingQueueTest {
+        protected BlockingQueue emptyCollection() {
+            return new DelayQueue();
+        }
+        protected PDelay makeElement(int i) {
+            return new PDelay(i);
+        }
+    }
+
     public static void main(String[] args) {
-        junit.textui.TestRunner.run (suite());
+        main(suite(), args);
     }
 
     public static Test suite() {
-        return new TestSuite(DelayQueueTest.class);
+        class Implementation implements CollectionImplementation {
+            public Class<?> klazz() { return DelayQueue.class; }
+            public Collection emptyCollection() { return new DelayQueue(); }
+            public Object makeElement(int i) { return new PDelay(i); }
+            public boolean isConcurrent() { return true; }
+            public boolean permitsNulls() { return false; }
+        }
+        return newTestSuite(DelayQueueTest.class,
+                            new Generic().testSuite(),
+                            CollectionTest.testSuite(new Implementation()));
     }
 
-    private static final int NOCAP = Integer.MAX_VALUE;
-
     /**
-     * A delayed implementation for testing.
-     * Most tests use Pseudodelays, where delays are all elapsed
+     * A fake Delayed implementation for testing.
+     * Most tests use PDelays, where delays are all elapsed
      * (so, no blocking solely for delays) but are still ordered
      */
     static class PDelay implements Delayed {
-        int pseudodelay;
-        PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; }
-        public int compareTo(PDelay y) {
-            int i = pseudodelay;
-            int j = y.pseudodelay;
-            if (i < j) return -1;
-            if (i > j) return 1;
-            return 0;
-        }
-
+        final int pseudodelay;
+        PDelay(int pseudodelay) { this.pseudodelay = pseudodelay; }
         public int compareTo(Delayed y) {
-            return compareTo((PDelay)y);
+            return Integer.compare(this.pseudodelay, ((PDelay)y).pseudodelay);
         }
-
         public boolean equals(Object other) {
-            return equals((PDelay)other);
-        }
-        public boolean equals(PDelay other) {
-            return other.pseudodelay == pseudodelay;
+            return (other instanceof PDelay) &&
+                this.pseudodelay == ((PDelay)other).pseudodelay;
         }
-
-
+        // suppress [overrides] javac warning
+        public int hashCode() { return pseudodelay; }
         public long getDelay(TimeUnit ignore) {
-            return pseudodelay;
-        }
-        public int intValue() {
-            return pseudodelay;
+            return (long) Integer.MIN_VALUE + pseudodelay;
         }
-
         public String toString() {
             return String.valueOf(pseudodelay);
         }
     }
 
-
     /**
      * Delayed implementation that actually delays
      */
     static class NanoDelay implements Delayed {
-        long trigger;
+        final long trigger;
         NanoDelay(long i) {
             trigger = System.nanoTime() + i;
         }
-        public int compareTo(NanoDelay y) {
-            long i = trigger;
-            long j = y.trigger;
-            if (i < j) return -1;
-            if (i > j) return 1;
-            return 0;
-        }
 
         public int compareTo(Delayed y) {
-            return compareTo((NanoDelay)y);
+            return Long.compare(trigger, ((NanoDelay)y).trigger);
         }
 
         public boolean equals(Object other) {
-            return equals((NanoDelay)other);
-        }
-        public boolean equals(NanoDelay other) {
-            return other.trigger == trigger;
+            return (other instanceof NanoDelay) &&
+                this.trigger == ((NanoDelay)other).trigger;
         }
 
+        // suppress [overrides] javac warning
+        public int hashCode() { return (int) trigger; }
+
         public long getDelay(TimeUnit unit) {
             long n = trigger - System.nanoTime();
             return unit.convert(n, TimeUnit.NANOSECONDS);
@@ -104,21 +111,21 @@ public class DelayQueueTest extends JSR1
         }
     }
 
-
     /**
-     * Create a queue of given size containing consecutive
-     * PDelays 0 ... n.
+     * Returns a new queue of given size containing consecutive
+     * PDelays 0 ... n - 1.
      */
-    private DelayQueue populatedQueue(int n) {
-        DelayQueue q = new DelayQueue();
+    private static DelayQueue<PDelay> populatedQueue(int n) {
+        DelayQueue<PDelay> q = new DelayQueue<>();
         assertTrue(q.isEmpty());
-        for (int i = n-1; i >= 0; i-=2)
+        for (int i = n - 1; i >= 0; i -= 2)
             assertTrue(q.offer(new PDelay(i)));
-        for (int i = (n & 1); i < n; i+=2)
+        for (int i = (n & 1); i < n; i += 2)
             assertTrue(q.offer(new PDelay(i)));
         assertFalse(q.isEmpty());
-        assertEquals(NOCAP, q.remainingCapacity());
-        assertEquals(n, q.size());
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
+        mustEqual(n, q.size());
+        mustEqual(new PDelay(0), q.peek());
         return q;
     }
 
@@ -126,7 +133,7 @@ public class DelayQueueTest extends JSR1
      * A new queue has unbounded capacity
      */
     public void testConstructor1() {
-        assertEquals(NOCAP, new DelayQueue().remainingCapacity());
+        mustEqual(Integer.MAX_VALUE, new DelayQueue<PDelay>().remainingCapacity());
     }
 
     /**
@@ -134,7 +141,7 @@ public class DelayQueueTest extends JSR1
      */
     public void testConstructor3() {
         try {
-            DelayQueue q = new DelayQueue(null);
+            new DelayQueue<PDelay>(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -144,8 +151,7 @@ public class DelayQueueTest extends JSR1
      */
     public void testConstructor4() {
         try {
-            PDelay[] ints = new PDelay[SIZE];
-            DelayQueue q = new DelayQueue(Arrays.asList(ints));
+            new DelayQueue<PDelay>(Arrays.asList(new PDelay[SIZE]));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -154,11 +160,11 @@ public class DelayQueueTest extends JSR1
      * Initializing from Collection with some null elements throws NPE
      */
     public void testConstructor5() {
+        PDelay[] a = new PDelay[SIZE];
+        for (int i = 0; i < SIZE - 1; ++i)
+            a[i] = new PDelay(i);
         try {
-            PDelay[] ints = new PDelay[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new PDelay(i);
-            DelayQueue q = new DelayQueue(Arrays.asList(ints));
+            new DelayQueue<PDelay>(Arrays.asList(a));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -167,21 +173,21 @@ public class DelayQueueTest extends JSR1
      * Queue contains all elements of collection used to initialize
      */
     public void testConstructor6() {
-        PDelay[] ints = new PDelay[SIZE];
+        PDelay[] items = new PDelay[SIZE];
         for (int i = 0; i < SIZE; ++i)
-            ints[i] = new PDelay(i);
-        DelayQueue q = new DelayQueue(Arrays.asList(ints));
+            items[i] = new PDelay(i);
+        DelayQueue<PDelay> q = new DelayQueue<>(Arrays.asList(items));
         for (int i = 0; i < SIZE; ++i)
-            assertEquals(ints[i], q.poll());
+            mustEqual(items[i], q.poll());
     }
 
     /**
      * isEmpty is true before add, false after
      */
     public void testEmpty() {
-        DelayQueue q = new DelayQueue();
+        DelayQueue<PDelay> q = new DelayQueue<>();
         assertTrue(q.isEmpty());
-        assertEquals(NOCAP, q.remainingCapacity());
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
         q.add(new PDelay(1));
         assertFalse(q.isEmpty());
         q.add(new PDelay(2));
@@ -191,50 +197,27 @@ public class DelayQueueTest extends JSR1
     }
 
     /**
-     * remainingCapacity does not change when elements added or removed,
-     * but size does
+     * remainingCapacity() always returns Integer.MAX_VALUE
      */
     public void testRemainingCapacity() {
-        DelayQueue q = populatedQueue(SIZE);
+        BlockingQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(NOCAP, q.remainingCapacity());
-            assertEquals(SIZE-i, q.size());
-            q.remove();
+            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
+            mustEqual(SIZE - i, q.size());
+            assertTrue(q.remove() instanceof PDelay);
         }
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(NOCAP, q.remainingCapacity());
-            assertEquals(i, q.size());
-            q.add(new PDelay(i));
+            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
+            mustEqual(i, q.size());
+            assertTrue(q.add(new PDelay(i)));
         }
     }
 
     /**
-     * offer(null) throws NPE
-     */
-    public void testOfferNull() {
-        try {
-            DelayQueue q = new DelayQueue();
-            q.offer(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * add(null) throws NPE
-     */
-    public void testAddNull() {
-        try {
-            DelayQueue q = new DelayQueue();
-            q.add(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
      * offer non-null succeeds
      */
     public void testOffer() {
-        DelayQueue q = new DelayQueue();
+        DelayQueue<PDelay> q = new DelayQueue<>();
         assertTrue(q.offer(new PDelay(0)));
         assertTrue(q.offer(new PDelay(1)));
     }
@@ -243,58 +226,35 @@ public class DelayQueueTest extends JSR1
      * add succeeds
      */
     public void testAdd() {
-        DelayQueue q = new DelayQueue();
+        DelayQueue<PDelay> q = new DelayQueue<>();
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
+            mustEqual(i, q.size());
             assertTrue(q.add(new PDelay(i)));
         }
     }
 
     /**
-     * addAll(null) throws NPE
-     */
-    public void testAddAll1() {
-        try {
-            DelayQueue q = new DelayQueue();
-            q.addAll(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-
-    /**
-     * addAll(this) throws IAE
+     * addAll(this) throws IllegalArgumentException
      */
     public void testAddAllSelf() {
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         try {
-            DelayQueue q = populatedQueue(SIZE);
             q.addAll(q);
             shouldThrow();
         } catch (IllegalArgumentException success) {}
     }
 
     /**
-     * addAll of a collection with null elements throws NPE
-     */
-    public void testAddAll2() {
-        try {
-            DelayQueue q = new DelayQueue();
-            PDelay[] ints = new PDelay[SIZE];
-            q.addAll(Arrays.asList(ints));
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-    /**
      * addAll of a collection with any null elements throws NPE after
      * possibly adding some elements
      */
     public void testAddAll3() {
+        DelayQueue<PDelay> q = new DelayQueue<>();
+        PDelay[] a = new PDelay[SIZE];
+        for (int i = 0; i < SIZE - 1; ++i)
+            a[i] = new PDelay(i);
         try {
-            DelayQueue q = new DelayQueue();
-            PDelay[] ints = new PDelay[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new PDelay(i);
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(a));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -304,46 +264,35 @@ public class DelayQueueTest extends JSR1
      */
     public void testAddAll5() {
         PDelay[] empty = new PDelay[0];
-        PDelay[] ints = new PDelay[SIZE];
-        for (int i = SIZE-1; i >= 0; --i)
-            ints[i] = new PDelay(i);
-        DelayQueue q = new DelayQueue();
+        PDelay[] items = new PDelay[SIZE];
+        for (int i = SIZE - 1; i >= 0; --i)
+            items[i] = new PDelay(i);
+        DelayQueue<PDelay> q = new DelayQueue<>();
         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 NPE
-     */
-     public void testPutNull() {
-        try {
-            DelayQueue q = new DelayQueue();
-            q.put(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-     }
-
-    /**
      * all elements successfully put are contained
      */
-     public void testPut() {
-         DelayQueue q = new DelayQueue();
-         for (int i = 0; i < SIZE; ++i) {
-             PDelay I = new PDelay(i);
-             q.put(I);
-             assertTrue(q.contains(I));
-         }
-         assertEquals(SIZE, q.size());
+    public void testPut() {
+        DelayQueue<PDelay> q = new DelayQueue<>();
+        for (int i = 0; i < SIZE; ++i) {
+            PDelay x = new PDelay(i);
+            q.put(x);
+            assertTrue(q.contains(x));
+        }
+        mustEqual(SIZE, q.size());
     }
 
     /**
      * put doesn't block waiting for take
      */
     public void testPutWithTake() throws InterruptedException {
-        final DelayQueue q = new DelayQueue();
-        Thread t = new Thread(new CheckedRunnable() {
+        final DelayQueue<PDelay> q = new DelayQueue<>();
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() {
                 q.put(new PDelay(0));
                 q.put(new PDelay(0));
@@ -351,19 +300,16 @@ public class DelayQueueTest extends JSR1
                 q.put(new PDelay(0));
             }});
 
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        q.take();
-        t.interrupt();
-        t.join();
+        awaitTermination(t);
+        mustEqual(4, q.size());
     }
 
     /**
-     * timed offer does not time out
+     * Queue is unbounded, so timed offer never times out
      */
     public void testTimedOffer() throws InterruptedException {
-        final DelayQueue q = new DelayQueue();
-        Thread t = new Thread(new CheckedRunnable() {
+        final DelayQueue<PDelay> q = new DelayQueue<>();
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.put(new PDelay(0));
                 q.put(new PDelay(0));
@@ -371,92 +317,87 @@ public class DelayQueueTest extends JSR1
                 assertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, MILLISECONDS));
             }});
 
-        t.start();
-        Thread.sleep(SMALL_DELAY_MS);
-        t.interrupt();
-        t.join();
+        awaitTermination(t);
     }
 
     /**
      * take retrieves elements in priority order
      */
     public void testTake() throws InterruptedException {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.take()));
+            mustEqual(new PDelay(i), q.take());
         }
     }
 
     /**
-     * take blocks interruptibly when empty
-     */
-    public void testTakeFromEmpty() throws InterruptedException {
-        final DelayQueue q = new DelayQueue();
-        Thread t = new ThreadShouldThrow(InterruptedException.class) {
-            public void realRun() throws InterruptedException {
-                q.take();
-            }};
-
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
      * Take removes existing elements until empty, then blocks interruptibly
      */
     public void testBlockingTake() throws InterruptedException {
-        final DelayQueue q = populatedQueue(SIZE);
-        Thread t = new Thread(new CheckedRunnable() {
+        final DelayQueue<PDelay> 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) {
-                    assertEquals(new PDelay(i), ((PDelay)q.take()));
-                }
+                for (int i = 0; i < SIZE; i++)
+                    mustEqual(new PDelay(i), q.take());
+
+                Thread.currentThread().interrupt();
+                try {
+                    q.take();
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
+
+                pleaseInterrupt.countDown();
                 try {
                     q.take();
                     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() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.poll()));
+            mustEqual(new PDelay(i), q.poll());
         }
         assertNull(q.poll());
     }
 
     /**
-     * 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 {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.poll(0, MILLISECONDS)));
+            mustEqual(new PDelay(i), q.poll(0, MILLISECONDS));
         }
         assertNull(q.poll(0, MILLISECONDS));
     }
 
     /**
-     * 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 {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
-        }
-        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
+            long startTime = System.nanoTime();
+            mustEqual(new PDelay(i), q.poll(LONG_DELAY_MS, MILLISECONDS));
+            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
+        }
+        long startTime = System.nanoTime();
+        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
+        checkEmpty(q);
     }
 
     /**
@@ -464,57 +405,44 @@ public class DelayQueueTest extends JSR1
      * returning timeout status
      */
     public void testInterruptedTimedPoll() throws InterruptedException {
-        Thread t = new Thread(new CheckedRunnable() {
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
+        final DelayQueue<PDelay> q = populatedQueue(SIZE);
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                DelayQueue q = populatedQueue(SIZE);
-                for (int i = 0; i < SIZE; ++i) {
-                    assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
-                }
+                for (int i = 0; i < SIZE; i++)
+                    mustEqual(new PDelay(i),
+                              q.poll(LONG_DELAY_MS, MILLISECONDS));
+
+                Thread.currentThread().interrupt();
                 try {
-                    q.poll(SMALL_DELAY_MS, MILLISECONDS);
+                    q.poll(randomTimeout(), randomTimeUnit());
                     shouldThrow();
                 } catch (InterruptedException success) {}
-            }});
+                assertFalse(Thread.interrupted());
 
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
-        t.interrupt();
-        t.join();
-    }
-
-    /**
-     *  timed poll before a delayed offer fails; after offer succeeds;
-     *  on interruption throws
-     */
-    public void testTimedPollWithOffer() throws InterruptedException {
-        final DelayQueue q = new DelayQueue();
-        final PDelay pdelay = new PDelay(0);
-        Thread t = new Thread(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
-                assertSame(pdelay, q.poll(LONG_DELAY_MS, MILLISECONDS));
+                pleaseInterrupt.countDown();
                 try {
-                    q.poll(LONG_DELAY_MS, MILLISECONDS);
+                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
                     shouldThrow();
                 } catch (InterruptedException success) {}
+                assertFalse(Thread.interrupted());
             }});
 
-        t.start();
-        Thread.sleep(SMALL_DELAY_MS);
-        assertTrue(q.offer(pdelay, SHORT_DELAY_MS, MILLISECONDS));
+        await(pleaseInterrupt);
+        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
         t.interrupt();
-        t.join();
+        awaitTermination(t);
+        checkEmpty(q);
     }
 
-
     /**
      * peek returns next element, or null if empty
      */
     public void testPeek() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.peek()));
-            assertEquals(new PDelay(i), ((PDelay)q.poll()));
+            mustEqual(new PDelay(i), q.peek());
+            mustEqual(new PDelay(i), q.poll());
             if (q.isEmpty())
                 assertNull(q.peek());
             else
@@ -527,9 +455,9 @@ public class DelayQueueTest extends JSR1
      * element returns next element, or throws NSEE if empty
      */
     public void testElement() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.element()));
+            mustEqual(new PDelay(i), q.element());
             q.poll();
         }
         try {
@@ -542,9 +470,9 @@ public class DelayQueueTest extends JSR1
      * remove removes next element, or throws NSEE if empty
      */
     public void testRemove() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(new PDelay(i), ((PDelay)q.remove()));
+            mustEqual(new PDelay(i), q.remove());
         }
         try {
             q.remove();
@@ -553,25 +481,10 @@ public class DelayQueueTest extends JSR1
     }
 
     /**
-     * remove(x) removes x and returns true if present
-     */
-    public void testRemoveElement() {
-        DelayQueue q = populatedQueue(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
-            assertTrue(q.remove(new PDelay(i)));
-        }
-        for (int i = 0; i < SIZE; i+=2) {
-            assertTrue(q.remove(new PDelay(i)));
-            assertFalse(q.remove(new PDelay(i+1)));
-        }
-        assertTrue(q.isEmpty());
-    }
-
-    /**
      * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.contains(new PDelay(i)));
             q.poll();
@@ -583,11 +496,11 @@ public class DelayQueueTest extends JSR1
      * clear removes all elements
      */
     public void testClear() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         q.clear();
         assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        assertEquals(NOCAP, q.remainingCapacity());
+        mustEqual(0, q.size());
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
         PDelay x = new PDelay(1);
         q.add(x);
         assertFalse(q.isEmpty());
@@ -600,8 +513,8 @@ public class DelayQueueTest extends JSR1
      * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
-        DelayQueue q = populatedQueue(SIZE);
-        DelayQueue p = new DelayQueue();
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
+        DelayQueue<PDelay> p = new DelayQueue<>();
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
@@ -614,8 +527,8 @@ public class DelayQueueTest extends JSR1
      * retainAll(c) retains only those elements of c and reports true if changed
      */
     public void testRetainAll() {
-        DelayQueue q = populatedQueue(SIZE);
-        DelayQueue p = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
+        DelayQueue<PDelay> p = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             boolean changed = q.retainAll(p);
             if (i == 0)
@@ -624,7 +537,7 @@ public class DelayQueueTest extends JSR1
                 assertTrue(changed);
 
             assertTrue(q.containsAll(p));
-            assertEquals(SIZE-i, q.size());
+            mustEqual(SIZE - i, q.size());
             p.remove();
         }
     }
@@ -634,13 +547,12 @@ public class DelayQueueTest extends JSR1
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
-            DelayQueue q = populatedQueue(SIZE);
-            DelayQueue p = populatedQueue(i);
+            DelayQueue<PDelay> q = populatedQueue(SIZE);
+            DelayQueue<PDelay> p = populatedQueue(i);
             assertTrue(q.removeAll(p));
-            assertEquals(SIZE-i, q.size());
+            mustEqual(SIZE - i, q.size());
             for (int j = 0; j < i; ++j) {
-                PDelay I = (PDelay)(p.remove());
-                assertFalse(q.contains(I));
+                assertFalse(q.contains(p.remove()));
             }
         }
     }
@@ -649,44 +561,37 @@ public class DelayQueueTest extends JSR1
      * toArray contains all elements
      */
     public void testToArray() throws InterruptedException {
-        DelayQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertEquals(o[i], q.take());
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        Arrays.sort(a);
+        for (Object o : a)
+            assertSame(o, q.take());
+        assertTrue(q.isEmpty());
     }
 
     /**
      * toArray(a) contains all elements
      */
-    public void testToArray2() throws InterruptedException {
-        DelayQueue q = populatedQueue(SIZE);
-        PDelay[] ints = new PDelay[SIZE];
-        ints = (PDelay[])q.toArray(ints);
-        Arrays.sort(ints);
-        for (int i = 0; i < ints.length; i++)
-            assertEquals(ints[i], q.take());
-    }
-
-
-    /**
-     * toArray(null) throws NPE
-     */
-    public void testToArray_BadArg() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            Object o[] = q.toArray(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
+    public void testToArray2() {
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
+        PDelay[] items = new PDelay[SIZE];
+        PDelay[] array = q.toArray(items);
+        assertSame(items, array);
+        Arrays.sort(items);
+        for (PDelay o : items)
+            assertSame(o, q.remove());
+        assertTrue(q.isEmpty());
     }
 
     /**
-     * toArray with incompatible array type throws CCE
+     * toArray(incompatible array type) throws ArrayStoreException
      */
-    public void testToArray1_BadArg() {
-        DelayQueue q = populatedQueue(SIZE);
+    @SuppressWarnings("CollectionToArraySafeParameter")
+    public void testToArray_incompatibleArrayType() {
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         try {
-            Object o[] = q.toArray(new String[10]);
+            q.toArray(new String[10]);
             shouldThrow();
         } catch (ArrayStoreException success) {}
     }
@@ -695,107 +600,109 @@ public class DelayQueueTest extends JSR1
      * iterator iterates through all elements
      */
     public void testIterator() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         int i = 0;
-        Iterator it = q.iterator();
+        Iterator<PDelay> it = q.iterator();
         while (it.hasNext()) {
             assertTrue(q.contains(it.next()));
             ++i;
         }
-        assertEquals(i, SIZE);
+        mustEqual(i, SIZE);
+        assertIteratorExhausted(it);
+    }
+
+    /**
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(new DelayQueue<PDelay>().iterator());
     }
 
     /**
      * iterator.remove removes current element
      */
-    public void testIteratorRemove () {
-        final DelayQueue q = new DelayQueue();
+    public void testIteratorRemove() {
+        final DelayQueue<PDelay> q = new DelayQueue<>();
         q.add(new PDelay(2));
         q.add(new PDelay(1));
         q.add(new PDelay(3));
-        Iterator it = q.iterator();
+        Iterator<PDelay> it = q.iterator();
         it.next();
         it.remove();
         it = q.iterator();
-        assertEquals(it.next(), new PDelay(2));
-        assertEquals(it.next(), new PDelay(3));
+        mustEqual(new PDelay(2), it.next());
+        mustEqual(new PDelay(3), it.next());
         assertFalse(it.hasNext());
     }
 
-
     /**
      * toString contains toStrings of elements
      */
     public void testToString() {
-        DelayQueue q = populatedQueue(SIZE);
+        DelayQueue<PDelay> q = populatedQueue(SIZE);
         String s = q.toString();
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(Integer.MIN_VALUE+i)) >= 0);
-        }
+        for (Object e : q)
+            assertTrue(s.contains(e.toString()));
     }
 
     /**
-     * offer transfers elements across Executor tasks
+     * timed poll transfers elements across Executor tasks
      */
     public void testPollInExecutor() {
-        final DelayQueue q = new DelayQueue();
-        ExecutorService executor = Executors.newFixedThreadPool(2);
-        executor.execute(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                assertNull(q.poll());
-                assertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
-                assertTrue(q.isEmpty());
-            }});
-
-        executor.execute(new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                Thread.sleep(SHORT_DELAY_MS);
-                q.put(new PDelay(1));
-            }});
-
-        joinPool(executor);
+        final DelayQueue<PDelay> q = new DelayQueue<>();
+        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();
+                    assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
+                    checkEmpty(q);
+                }});
+
+            executor.execute(new CheckedRunnable() {
+                public void realRun() throws InterruptedException {
+                    threadsStarted.await();
+                    q.put(new PDelay(1));
+                }});
+        }
     }
 
-
     /**
      * Delayed actions do not occur until their delay elapses
      */
     public void testDelay() throws InterruptedException {
-        DelayQueue q = new DelayQueue();
-        NanoDelay[] elements = new NanoDelay[SIZE];
-        for (int i = 0; i < SIZE; ++i) {
-            elements[i] = new NanoDelay(1000000000L + 1000000L * (SIZE - i));
-        }
-        for (int i = 0; i < SIZE; ++i) {
-            q.add(elements[i]);
-        }
+        DelayQueue<NanoDelay> q = new DelayQueue<>();
+        for (int i = 0; i < SIZE; ++i)
+            q.add(new NanoDelay(1000000L * (SIZE - i)));
 
         long last = 0;
         for (int i = 0; i < SIZE; ++i) {
-            NanoDelay e = (NanoDelay)(q.take());
+            NanoDelay e = q.take();
             long tt = e.getTriggerTime();
-            assertTrue(tt <= System.nanoTime());
+            assertTrue(System.nanoTime() - tt >= 0);
             if (i != 0)
                 assertTrue(tt >= last);
             last = tt;
         }
+        assertTrue(q.isEmpty());
     }
 
     /**
      * peek of a non-empty queue returns non-null even if not expired
      */
     public void testPeekDelayed() {
-        DelayQueue q = new DelayQueue();
+        DelayQueue<NanoDelay> q = new DelayQueue<>();
         q.add(new NanoDelay(Long.MAX_VALUE));
-        assert(q.peek() != null);
+        assertNotNull(q.peek());
     }
 
-
     /**
      * poll of a non-empty queue returns null if no expired elements.
      */
     public void testPollDelayed() {
-        DelayQueue q = new DelayQueue();
+        DelayQueue<NanoDelay> q = new DelayQueue<>();
         q.add(new NanoDelay(Long.MAX_VALUE));
         assertNull(q.poll());
     }
@@ -804,48 +711,28 @@ public class DelayQueueTest extends JSR1
      * timed poll of a non-empty queue returns null if no expired elements.
      */
     public void testTimedPollDelayed() throws InterruptedException {
-        DelayQueue q = new DelayQueue();
+        DelayQueue<NanoDelay> q = new DelayQueue<>();
         q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
-        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
-    }
-
-    /**
-     * drainTo(null) throws NPE
-     */
-    public void testDrainToNull() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * drainTo(this) throws IAE
-     */
-    public void testDrainToSelf() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(q);
-            shouldThrow();
-        } catch (IllegalArgumentException success) {}
+        long startTime = System.nanoTime();
+        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
     }
 
     /**
      * drainTo(c) empties queue into another collection c
      */
     public void testDrainTo() {
-        DelayQueue q = new DelayQueue();
+        DelayQueue<PDelay> q = new DelayQueue<>();
         PDelay[] elems = new PDelay[SIZE];
         for (int i = 0; i < SIZE; ++i) {
             elems[i] = new PDelay(i);
             q.add(elems[i]);
         }
-        ArrayList l = new ArrayList();
+        ArrayList<PDelay> l = new ArrayList<>();
         q.drainTo(l);
-        assertEquals(q.size(), 0);
+        mustEqual(0, q.size());
         for (int i = 0; i < SIZE; ++i)
-            assertEquals(l.get(i), elems[i]);
+            mustEqual(elems[i], l.get(i));
         q.add(elems[0]);
         q.add(elems[1]);
         assertFalse(q.isEmpty());
@@ -853,24 +740,24 @@ public class DelayQueueTest extends JSR1
         assertTrue(q.contains(elems[1]));
         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), elems[i]);
+            mustEqual(elems[i], l.get(i));
     }
 
     /**
      * drainTo empties queue
      */
     public void testDrainToWithActivePut() throws InterruptedException {
-        final DelayQueue q = populatedQueue(SIZE);
+        final DelayQueue<PDelay> q = populatedQueue(SIZE);
         Thread t = new Thread(new CheckedRunnable() {
             public void realRun() {
-                q.put(new PDelay(SIZE+1));
+                q.put(new PDelay(SIZE + 1));
             }});
 
         t.start();
-        ArrayList l = new ArrayList();
+        ArrayList<PDelay> l = new ArrayList<>();
         q.drainTo(l);
         assertTrue(l.size() >= SIZE);
         t.join();
@@ -878,40 +765,25 @@ public class DelayQueueTest extends JSR1
     }
 
     /**
-     * drainTo(null, n) throws NPE
-     */
-    public void testDrainToNullN() {
-        DelayQueue q = populatedQueue(SIZE);
-        try {
-            q.drainTo(null, 0);
-            shouldThrow();
-        } catch (NullPointerException success) {}
-    }
-
-    /**
-     * drainTo(this, n) throws IAE
-     */
-    public void testDrainToSelfN() {
-        DelayQueue 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() {
         for (int i = 0; i < SIZE + 2; ++i) {
-            DelayQueue q = populatedQueue(SIZE);
-            ArrayList l = new ArrayList();
+            DelayQueue<PDelay> q = populatedQueue(SIZE);
+            ArrayList<PDelay> l = new ArrayList<>();
             q.drainTo(l, i);
-            int k = (i < SIZE)? i : SIZE;
-            assertEquals(q.size(), SIZE-k);
-            assertEquals(l.size(), k);
+            int k = (i < SIZE) ? i : SIZE;
+            mustEqual(SIZE - k, q.size());
+            mustEqual(k, l.size());
         }
     }
 
-
+    /**
+     * remove(null), contains(null) always return false
+     */
+    public void testNeverContainsNull() {
+        Collection<?> q = populatedQueue(SIZE);
+        assertFalse(q.contains(null));
+        assertFalse(q.remove(null));
+    }
 }