--- jsr166/src/test/tck/PriorityBlockingQueueTest.java	2019/09/05 21:11:13	1.84
+++ jsr166/src/test/tck/PriorityBlockingQueueTest.java	2021/01/26 13:33:06	1.85
@@ -50,19 +50,20 @@ public class PriorityBlockingQueueTest e
             public Collection emptyCollection() {
                 return new PriorityBlockingQueue();
             }
-            public Object makeElement(int i) { return i; }
+            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
             public boolean isConcurrent() { return true; }
             public boolean permitsNulls() { return false; }
         }
         class ComparatorImplementation implements CollectionImplementation {
             public Class<?> klazz() { return PriorityBlockingQueue.class; }
+            @SuppressWarnings("unchecked")
             public Collection emptyCollection() {
                 ThreadLocalRandom rnd = ThreadLocalRandom.current();
                 int initialCapacity = rnd.nextInt(1, 10);
                 return new PriorityBlockingQueue(
                     initialCapacity, new MyReverseComparator());
             }
-            public Object makeElement(int i) { return i; }
+            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
             public boolean isConcurrent() { return true; }
             public boolean permitsNulls() { return false; }
         }
@@ -76,6 +77,7 @@ public class PriorityBlockingQueueTest e
 
     /** Sample Comparator */
     static class MyReverseComparator implements Comparator, java.io.Serializable {
+        @SuppressWarnings("unchecked")
         public int compare(Object x, Object y) {
             return ((Comparable)y).compareTo(x);
         }
@@ -83,20 +85,20 @@ public class PriorityBlockingQueueTest e
 
     /**
      * Returns a new queue of given size containing consecutive
-     * Integers 0 ... n - 1.
+     * Items 0 ... n - 1.
      */
-    private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
-        PriorityBlockingQueue<Integer> q =
-            new PriorityBlockingQueue<Integer>(n);
+    private static PriorityBlockingQueue<Item> populatedQueue(int n) {
+        PriorityBlockingQueue<Item> q =
+            new PriorityBlockingQueue<Item>(n);
         assertTrue(q.isEmpty());
         for (int i = n - 1; i >= 0; i -= 2)
-            assertTrue(q.offer(new Integer(i)));
+            mustOffer(q, i);
         for (int i = (n & 1); i < n; i += 2)
-            assertTrue(q.offer(new Integer(i)));
+            mustOffer(q, i);
         assertFalse(q.isEmpty());
-        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
-        assertEquals(n, q.size());
-        assertEquals((Integer) 0, q.peek());
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
+        mustEqual(n, q.size());
+        mustEqual(0, q.peek());
         return q;
     }
 
@@ -104,8 +106,8 @@ public class PriorityBlockingQueueTest e
      * A new queue has unbounded capacity
      */
     public void testConstructor1() {
-        assertEquals(Integer.MAX_VALUE,
-                     new PriorityBlockingQueue(SIZE).remainingCapacity());
+        mustEqual(Integer.MAX_VALUE,
+                     new PriorityBlockingQueue<Item>(SIZE).remainingCapacity());
     }
 
     /**
@@ -113,7 +115,7 @@ public class PriorityBlockingQueueTest e
      */
     public void testConstructor2() {
         try {
-            new PriorityBlockingQueue(0);
+            new PriorityBlockingQueue<Item>(0);
             shouldThrow();
         } catch (IllegalArgumentException success) {}
     }
@@ -123,7 +125,7 @@ public class PriorityBlockingQueueTest e
      */
     public void testConstructor3() {
         try {
-            new PriorityBlockingQueue(null);
+            new PriorityBlockingQueue<Item>(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -132,9 +134,9 @@ public class PriorityBlockingQueueTest e
      * Initializing from Collection of null elements throws NPE
      */
     public void testConstructor4() {
-        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
+        Collection<Item> elements = Arrays.asList(new Item[SIZE]);
         try {
-            new PriorityBlockingQueue(elements);
+            new PriorityBlockingQueue<Item>(elements);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -143,12 +145,10 @@ public class PriorityBlockingQueueTest e
      * Initializing from Collection with some null elements throws NPE
      */
     public void testConstructor5() {
-        Integer[] ints = new Integer[SIZE];
-        for (int i = 0; i < SIZE - 1; ++i)
-            ints[i] = i;
-        Collection<Integer> elements = Arrays.asList(ints);
+        Item[] items = new Item[2]; items[0] = zero;
+        Collection<Item> elements = Arrays.asList(items);
         try {
-            new PriorityBlockingQueue(elements);
+            new PriorityBlockingQueue<Item>(elements);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -157,12 +157,10 @@ public class PriorityBlockingQueueTest e
      * Queue contains all elements of collection used to initialize
      */
     public void testConstructor6() {
-        Integer[] ints = new Integer[SIZE];
+        Item[] items = defaultItems;
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(Arrays.asList(items));
         for (int i = 0; i < SIZE; ++i)
-            ints[i] = i;
-        PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
-        for (int i = 0; i < SIZE; ++i)
-            assertEquals(ints[i], q.poll());
+            mustEqual(items[i], q.poll());
     }
 
     /**
@@ -170,23 +168,22 @@ public class PriorityBlockingQueueTest e
      */
     public void testConstructor7() {
         MyReverseComparator cmp = new MyReverseComparator();
-        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE, cmp);
-        assertEquals(cmp, q.comparator());
-        Integer[] ints = new Integer[SIZE];
-        for (int i = 0; i < SIZE; ++i)
-            ints[i] = new Integer(i);
-        q.addAll(Arrays.asList(ints));
+        @SuppressWarnings("unchecked")
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE, cmp);
+        mustEqual(cmp, q.comparator());
+        Item[] items = defaultItems;
+        q.addAll(Arrays.asList(items));
         for (int i = SIZE - 1; i >= 0; --i)
-            assertEquals(ints[i], q.poll());
+            mustEqual(items[i], q.poll());
     }
 
     /**
      * isEmpty is true before add, false after
      */
     public void testEmpty() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
         assertTrue(q.isEmpty());
-        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
+        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
         q.add(one);
         assertFalse(q.isEmpty());
         q.add(two);
@@ -199,16 +196,16 @@ public class PriorityBlockingQueueTest e
      * remainingCapacity() always returns Integer.MAX_VALUE
      */
     public void testRemainingCapacity() {
-        BlockingQueue 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());
-            assertEquals(i, 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());
-            assertTrue(q.add(i));
+            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
+            mustEqual(i, q.size());
+            mustAdd(q, i);
         }
     }
 
@@ -216,7 +213,7 @@ public class PriorityBlockingQueueTest e
      * Offer of comparable element succeeds
      */
     public void testOffer() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(1);
         assertTrue(q.offer(zero));
         assertTrue(q.offer(one));
     }
@@ -225,13 +222,13 @@ public class PriorityBlockingQueueTest e
      * Offer of non-Comparable throws CCE
      */
     public void testOfferNonComparable() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
+        PriorityBlockingQueue<Object> q = new PriorityBlockingQueue<Object>(1);
         try {
             q.offer(new Object());
             shouldThrow();
         } catch (ClassCastException success) {
             assertTrue(q.isEmpty());
-            assertEquals(0, q.size());
+            mustEqual(0, q.size());
             assertNull(q.poll());
         }
     }
@@ -240,10 +237,10 @@ public class PriorityBlockingQueueTest e
      * add of comparable succeeds
      */
     public void testAdd() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            assertTrue(q.add(new Integer(i)));
+            mustEqual(i, q.size());
+            mustAdd(q, i);
         }
     }
 
@@ -251,7 +248,7 @@ public class PriorityBlockingQueueTest e
      * addAll(this) throws IllegalArgumentException
      */
     public void testAddAllSelf() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         try {
             q.addAll(q);
             shouldThrow();
@@ -263,12 +260,11 @@ public class PriorityBlockingQueueTest e
      * possibly adding some elements
      */
     public void testAddAll3() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
-        Integer[] ints = new Integer[SIZE];
-        for (int i = 0; i < SIZE - 1; ++i)
-            ints[i] = new Integer(i);
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
+        Item[] items = new Item[2];
+        items[0] = zero;
         try {
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(items));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -277,44 +273,42 @@ public class PriorityBlockingQueueTest e
      * Queue contains all elements of successful addAll
      */
     public void testAddAll5() {
-        Integer[] empty = new Integer[0];
-        Integer[] ints = new Integer[SIZE];
-        for (int i = SIZE - 1; i >= 0; --i)
-            ints[i] = new Integer(i);
-        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+        Item[] empty = new Item[0];
+        Item[] items = defaultItems;
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
         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());
     }
 
     /**
      * all elements successfully put are contained
      */
     public void testPut() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            Integer x = new Integer(i);
+            Item x = itemFor(i);
             q.put(x);
-            assertTrue(q.contains(x));
+            mustContain(q, x);
         }
-        assertEquals(SIZE, q.size());
+        mustEqual(SIZE, q.size());
     }
 
     /**
      * put doesn't block waiting for take
      */
     public void testPutWithTake() throws InterruptedException {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
         final int size = 4;
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() {
                 for (int i = 0; i < size; i++)
-                    q.put(new Integer(0));
+                    q.put(zero);
             }});
 
         awaitTermination(t);
-        assertEquals(size, q.size());
+        mustEqual(size, q.size());
         q.take();
     }
 
@@ -322,13 +316,13 @@ public class PriorityBlockingQueueTest e
      * Queue is unbounded, so timed offer never times out
      */
     public void testTimedOffer() {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() {
-                q.put(new Integer(0));
-                q.put(new Integer(0));
-                assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
-                assertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS));
+                q.put(one);
+                q.put(two);
+                assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
+                assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
             }});
 
         awaitTermination(t);
@@ -338,9 +332,9 @@ public class PriorityBlockingQueueTest e
      * take retrieves elements in priority order
      */
     public void testTake() throws InterruptedException {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.take());
+            mustEqual(i, q.take());
         }
     }
 
@@ -348,11 +342,11 @@ public class PriorityBlockingQueueTest e
      * Take removes existing elements until empty, then blocks interruptibly
      */
     public void testBlockingTake() throws InterruptedException {
-        final PriorityBlockingQueue q = populatedQueue(SIZE);
+        final PriorityBlockingQueue<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++) assertEquals(i, q.take());
+                for (int i = 0; i < SIZE; i++) mustEqual(i, q.take());
 
                 Thread.currentThread().interrupt();
                 try {
@@ -379,9 +373,9 @@ public class PriorityBlockingQueueTest e
      * poll succeeds unless empty
      */
     public void testPoll() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.poll());
+            mustEqual(i, q.poll());
         }
         assertNull(q.poll());
     }
@@ -390,9 +384,9 @@ public class PriorityBlockingQueueTest e
      * timed poll with zero timeout succeeds when non-empty, else times out
      */
     public void testTimedPoll0() throws InterruptedException {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.poll(0, MILLISECONDS));
+            mustEqual(i, q.poll(0, MILLISECONDS));
         }
         assertNull(q.poll(0, MILLISECONDS));
     }
@@ -401,10 +395,10 @@ public class PriorityBlockingQueueTest e
      * timed poll with nonzero timeout succeeds when non-empty, else times out
      */
     public void testTimedPoll() throws InterruptedException {
-        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             long startTime = System.nanoTime();
-            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
+            mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
             assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
         }
         long startTime = System.nanoTime();
@@ -418,12 +412,12 @@ public class PriorityBlockingQueueTest e
      * returning timeout status
      */
     public void testInterruptedTimedPoll() throws InterruptedException {
-        final BlockingQueue<Integer> q = populatedQueue(SIZE);
+        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++)
-                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
+                    mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
 
                 Thread.currentThread().interrupt();
                 try {
@@ -450,10 +444,10 @@ public class PriorityBlockingQueueTest e
      * peek returns next element, or null if empty
      */
     public void testPeek() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.peek());
-            assertEquals(i, q.poll());
+            mustEqual(i, q.peek());
+            mustEqual(i, q.poll());
             assertTrue(q.peek() == null ||
                        !q.peek().equals(i));
         }
@@ -464,10 +458,10 @@ public class PriorityBlockingQueueTest e
      * element returns next element, or throws NSEE if empty
      */
     public void testElement() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.element());
-            assertEquals(i, q.poll());
+            mustEqual(i, q.element());
+            mustEqual(i, q.poll());
         }
         try {
             q.element();
@@ -479,9 +473,9 @@ public class PriorityBlockingQueueTest e
      * remove removes next element, or throws NSEE if empty
      */
     public void testRemove() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.remove());
+            mustEqual(i, q.remove());
         }
         try {
             q.remove();
@@ -493,11 +487,11 @@ public class PriorityBlockingQueueTest e
      * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertTrue(q.contains(new Integer(i)));
+            mustContain(q, i);
             q.poll();
-            assertFalse(q.contains(new Integer(i)));
+            mustNotContain(q, i);
         }
     }
 
@@ -505,13 +499,13 @@ public class PriorityBlockingQueueTest e
      * clear removes all elements
      */
     public void testClear() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         q.clear();
         assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
+        mustEqual(0, q.size());
         q.add(one);
         assertFalse(q.isEmpty());
-        assertTrue(q.contains(one));
+        mustContain(q, one);
         q.clear();
         assertTrue(q.isEmpty());
     }
@@ -520,12 +514,12 @@ public class PriorityBlockingQueueTest e
      * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        PriorityBlockingQueue p = new PriorityBlockingQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> p = new PriorityBlockingQueue<Item>(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
-            p.add(new Integer(i));
+            mustAdd(p, i);
         }
         assertTrue(p.containsAll(q));
     }
@@ -534,8 +528,8 @@ public class PriorityBlockingQueueTest e
      * retainAll(c) retains only those elements of c and reports true if changed
      */
     public void testRetainAll() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        PriorityBlockingQueue p = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> p = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             boolean changed = q.retainAll(p);
             if (i == 0)
@@ -544,7 +538,7 @@ public class PriorityBlockingQueueTest e
                 assertTrue(changed);
 
             assertTrue(q.containsAll(p));
-            assertEquals(SIZE - i, q.size());
+            mustEqual(SIZE - i, q.size());
             p.remove();
         }
     }
@@ -554,13 +548,13 @@ public class PriorityBlockingQueueTest e
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
-            PriorityBlockingQueue q = populatedQueue(SIZE);
-            PriorityBlockingQueue p = populatedQueue(i);
+            PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
+            PriorityBlockingQueue<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) {
-                Integer x = (Integer)(p.remove());
-                assertFalse(q.contains(x));
+                Item x = p.remove();
+                mustNotContain(q, x);
             }
         }
     }
@@ -569,7 +563,7 @@ public class PriorityBlockingQueueTest e
      * toArray contains all elements
      */
     public void testToArray() throws InterruptedException {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         Object[] a = q.toArray();
         assertSame(Object[].class, a.getClass());
         Arrays.sort(a);
@@ -582,12 +576,12 @@ public class PriorityBlockingQueueTest e
      * toArray(a) contains all elements
      */
     public void testToArray2() throws InterruptedException {
-        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
-        Integer[] ints = new Integer[SIZE];
-        Integer[] array = q.toArray(ints);
-        assertSame(ints, array);
-        Arrays.sort(ints);
-        for (Integer o : ints)
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
+        Item[] items = new Item[SIZE];
+        Item[] array = q.toArray(items);
+        assertSame(items, array);
+        Arrays.sort(items);
+        for (Item o : items)
             assertSame(o, q.take());
         assertTrue(q.isEmpty());
     }
@@ -596,7 +590,7 @@ public class PriorityBlockingQueueTest e
      * toArray(incompatible array type) throws ArrayStoreException
      */
     public void testToArray1_BadArg() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         try {
             q.toArray(new String[10]);
             shouldThrow();
@@ -607,12 +601,12 @@ public class PriorityBlockingQueueTest e
      * iterator iterates through all elements
      */
     public void testIterator() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        Iterator it = q.iterator();
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
+        Iterator<? extends Item> it = q.iterator();
         int i;
         for (i = 0; it.hasNext(); i++)
-            assertTrue(q.contains(it.next()));
-        assertEquals(i, SIZE);
+            mustContain(q, it.next());
+        mustEqual(i, SIZE);
         assertIteratorExhausted(it);
     }
 
@@ -620,25 +614,25 @@ public class PriorityBlockingQueueTest e
      * iterator of empty collection has no elements
      */
     public void testEmptyIterator() {
-        assertIteratorExhausted(new PriorityBlockingQueue().iterator());
+        assertIteratorExhausted(new PriorityBlockingQueue<Item>().iterator());
     }
 
     /**
      * iterator.remove removes current element
      */
     public void testIteratorRemove() {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(3);
-        q.add(new Integer(2));
-        q.add(new Integer(1));
-        q.add(new Integer(3));
+        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(3);
+        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(), new Integer(2));
-        assertEquals(it.next(), new Integer(3));
+        mustEqual(it.next(), two);
+        mustEqual(it.next(), three);
         assertFalse(it.hasNext());
     }
 
@@ -646,7 +640,7 @@ public class PriorityBlockingQueueTest e
      * toString contains toStrings of elements
      */
     public void testToString() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         String s = q.toString();
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(s.contains(String.valueOf(i)));
@@ -657,7 +651,7 @@ public class PriorityBlockingQueueTest e
      * timed poll transfers elements across Executor tasks
      */
     public void testPollInExecutor() {
-        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
+        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
         final CheckedBarrier threadsStarted = new CheckedBarrier(2);
         final ExecutorService executor = Executors.newFixedThreadPool(2);
         try (PoolCleaner cleaner = cleaner(executor)) {
@@ -681,14 +675,14 @@ public class PriorityBlockingQueueTest e
      * A deserialized/reserialized queue has same elements
      */
     public void testSerialization() throws Exception {
-        Queue x = populatedQueue(SIZE);
-        Queue y = serialClone(x);
+        Queue<Item> x = populatedQueue(SIZE);
+        Queue<Item> y = serialClone(x);
 
         assertNotSame(x, y);
-        assertEquals(x.size(), y.size());
+        mustEqual(x.size(), y.size());
         while (!x.isEmpty()) {
             assertFalse(y.isEmpty());
-            assertEquals(x.remove(), y.remove());
+            mustEqual(x.remove(), y.remove());
         }
         assertTrue(y.isEmpty());
     }
@@ -697,42 +691,41 @@ public class PriorityBlockingQueueTest e
      * drainTo(c) empties queue into another collection c
      */
     public void testDrainTo() {
-        PriorityBlockingQueue q = populatedQueue(SIZE);
-        ArrayList l = new ArrayList();
+        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
+        ArrayList<Item> l = new ArrayList<Item>();
         q.drainTo(l);
-        assertEquals(0, q.size());
-        assertEquals(SIZE, l.size());
+        mustEqual(0, q.size());
+        mustEqual(SIZE, l.size());
         for (int i = 0; i < SIZE; ++i)
-            assertEquals(l.get(i), new Integer(i));
+            mustEqual(l.get(i), i);
         q.add(zero);
         q.add(one);
         assertFalse(q.isEmpty());
-        assertTrue(q.contains(zero));
-        assertTrue(q.contains(one));
+        mustContain(q, one);
         l.clear();
         q.drainTo(l);
-        assertEquals(0, q.size());
-        assertEquals(2, l.size());
+        mustEqual(0, q.size());
+        mustEqual(2, l.size());
         for (int i = 0; i < 2; ++i)
-            assertEquals(l.get(i), new Integer(i));
+            mustEqual(l.get(i), i);
     }
 
     /**
      * drainTo empties queue
      */
     public void testDrainToWithActivePut() throws InterruptedException {
-        final PriorityBlockingQueue q = populatedQueue(SIZE);
+        final PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
         Thread t = new Thread(new CheckedRunnable() {
             public void realRun() {
-                q.put(new Integer(SIZE + 1));
+                q.put(new Item(SIZE + 1));
             }});
 
         t.start();
-        ArrayList l = new ArrayList();
+        ArrayList<Item> l = new ArrayList<Item>();
         q.drainTo(l);
         assertTrue(l.size() >= SIZE);
         for (int i = 0; i < SIZE; ++i)
-            assertEquals(l.get(i), new Integer(i));
+            mustEqual(l.get(i), i);
         t.join();
         assertTrue(q.size() + l.size() >= SIZE);
     }
@@ -741,17 +734,17 @@ public class PriorityBlockingQueueTest e
      * drainTo(c, n) empties first min(n, size) elements of queue into c
      */
     public void testDrainToN() {
-        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
+        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE * 2);
         for (int i = 0; i < SIZE + 2; ++i) {
             for (int j = 0; j < SIZE; j++)
-                assertTrue(q.offer(new Integer(j)));
-            ArrayList l = new ArrayList();
+                mustOffer(q, j);
+            ArrayList<Item> l = new ArrayList<Item>();
             q.drainTo(l, i);
             int k = (i < SIZE) ? i : SIZE;
-            assertEquals(k, l.size());
-            assertEquals(SIZE - k, q.size());
+            mustEqual(k, l.size());
+            mustEqual(SIZE - k, q.size());
             for (int j = 0; j < k; ++j)
-                assertEquals(l.get(j), new Integer(j));
+                mustEqual(l.get(j), j);
             do {} while (q.poll() != null);
         }
     }