--- jsr166/src/test/tck/ConcurrentLinkedQueueTest.java	2012/02/21 02:04:17	1.29
+++ jsr166/src/test/tck/ConcurrentLinkedQueueTest.java	2021/01/26 13:33:05	1.50
@@ -6,7 +6,6 @@
  * Pat Fisher, Mike Judd.
  */
 
-import junit.framework.*;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
@@ -14,27 +13,38 @@ import java.util.NoSuchElementException;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
+import junit.framework.Test;
+
 public class ConcurrentLinkedQueueTest extends JSR166TestCase {
 
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
 
     public static Test suite() {
-        return new TestSuite(ConcurrentLinkedQueueTest.class);
+        class Implementation implements CollectionImplementation {
+            public Class<?> klazz() { return ConcurrentLinkedQueue.class; }
+            public Collection emptyCollection() { return new ConcurrentLinkedQueue(); }
+            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
+            public boolean isConcurrent() { return true; }
+            public boolean permitsNulls() { return false; }
+        }
+        return newTestSuite(ConcurrentLinkedQueueTest.class,
+                            CollectionTest.testSuite(new Implementation()));
     }
 
     /**
      * Returns a new queue of given size containing consecutive
-     * Integers 0 ... n.
+     * Items 0 ... n - 1.
      */
-    private ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
-        ConcurrentLinkedQueue<Integer> q = new ConcurrentLinkedQueue<Integer>();
+    private static ConcurrentLinkedQueue<Item> populatedQueue(int n) {
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<>();
         assertTrue(q.isEmpty());
         for (int i = 0; i < n; ++i)
-            assertTrue(q.offer(new Integer(i)));
+            mustOffer(q, i);
         assertFalse(q.isEmpty());
-        assertEquals(n, q.size());
+        mustEqual(n, q.size());
+        mustEqual(0, q.peek());
         return q;
     }
 
@@ -42,7 +52,7 @@ public class ConcurrentLinkedQueueTest e
      * new queue is empty
      */
     public void testConstructor1() {
-        assertEquals(0, new ConcurrentLinkedQueue().size());
+        mustEqual(0, new ConcurrentLinkedQueue<Item>().size());
     }
 
     /**
@@ -50,7 +60,7 @@ public class ConcurrentLinkedQueueTest e
      */
     public void testConstructor3() {
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
+            new ConcurrentLinkedQueue<Item>((Collection<Item>)null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -60,8 +70,7 @@ public class ConcurrentLinkedQueueTest e
      */
     public void testConstructor4() {
         try {
-            Integer[] ints = new Integer[SIZE];
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
+            new ConcurrentLinkedQueue<Item>(Arrays.asList(new Item[SIZE]));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -70,11 +79,10 @@ public class ConcurrentLinkedQueueTest e
      * Initializing from Collection with some null elements throws NPE
      */
     public void testConstructor5() {
+        Item[] items = new Item[2];
+        items[0] = zero;
         try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new Integer(i);
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
+            new ConcurrentLinkedQueue<Item>(Arrays.asList(items));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -83,19 +91,17 @@ public class ConcurrentLinkedQueueTest e
      * Queue contains all elements of collection used to initialize
      */
     public void testConstructor6() {
-        Integer[] ints = new Integer[SIZE];
+        Item[] items = defaultItems;
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>(Arrays.asList(items));
         for (int i = 0; i < SIZE; ++i)
-            ints[i] = new Integer(i);
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
-        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() {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         assertTrue(q.isEmpty());
         q.add(one);
         assertFalse(q.isEmpty());
@@ -109,14 +115,14 @@ public class ConcurrentLinkedQueueTest e
      * size changes when elements added and removed
      */
     public void testSize() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(SIZE-i, q.size());
+            mustEqual(SIZE - i, q.size());
             q.remove();
         }
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            q.add(new Integer(i));
+            mustEqual(i, q.size());
+            mustAdd(q, i);
         }
     }
 
@@ -124,8 +130,8 @@ public class ConcurrentLinkedQueueTest e
      * offer(null) throws NPE
      */
     public void testOfferNull() {
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
             q.offer(null);
             shouldThrow();
         } catch (NullPointerException success) {}
@@ -135,8 +141,8 @@ public class ConcurrentLinkedQueueTest e
      * add(null) throws NPE
      */
     public void testAddNull() {
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
             q.add(null);
             shouldThrow();
         } catch (NullPointerException success) {}
@@ -146,7 +152,7 @@ public class ConcurrentLinkedQueueTest e
      * Offer returns true
      */
     public void testOffer() {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         assertTrue(q.offer(zero));
         assertTrue(q.offer(one));
     }
@@ -155,43 +161,42 @@ public class ConcurrentLinkedQueueTest e
      * add returns true
      */
     public void testAdd() {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            assertTrue(q.add(new Integer(i)));
+            mustEqual(i, q.size());
+            mustAdd(q, i);
         }
     }
 
     /**
-     * addAll(null) throws NPE
+     * addAll(null) throws NullPointerException
      */
     public void testAddAll1() {
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
             q.addAll(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
 
     /**
-     * addAll(this) throws IAE
+     * addAll(this) throws IllegalArgumentException
      */
     public void testAddAllSelf() {
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         try {
-            ConcurrentLinkedQueue q = populatedQueue(SIZE);
             q.addAll(q);
             shouldThrow();
         } catch (IllegalArgumentException success) {}
     }
 
     /**
-     * addAll of a collection with null elements throws NPE
+     * addAll of a collection with null elements throws NullPointerException
      */
     public void testAddAll2() {
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            Integer[] ints = new Integer[SIZE];
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(new Item[SIZE]));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -201,12 +206,11 @@ public class ConcurrentLinkedQueueTest e
      * possibly adding some elements
      */
     public void testAddAll3() {
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
+        Item[] items = new Item[2];
+        items[0] = zero;
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE-1; ++i)
-                ints[i] = new Integer(i);
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(items));
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -215,24 +219,22 @@ public class ConcurrentLinkedQueueTest e
      * 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] = new Integer(i);
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        Item[] empty = new Item[0];
+        Item[] items = defaultItems;
+        ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         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());
     }
 
     /**
      * poll succeeds unless empty
      */
     public void testPoll() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.poll());
+            mustEqual(i, q.poll());
         }
         assertNull(q.poll());
     }
@@ -241,10 +243,10 @@ public class ConcurrentLinkedQueueTest e
      * peek returns next element, or null if empty
      */
     public void testPeek() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<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));
         }
@@ -255,10 +257,10 @@ public class ConcurrentLinkedQueueTest e
      * element returns next element, or throws NSEE if empty
      */
     public void testElement() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<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();
@@ -270,9 +272,9 @@ public class ConcurrentLinkedQueueTest e
      * remove removes next element, or throws NSEE if empty
      */
     public void testRemove() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.remove());
+            mustEqual(i, q.remove());
         }
         try {
             q.remove();
@@ -284,19 +286,19 @@ public class ConcurrentLinkedQueueTest e
      * remove(x) removes x and returns true if present
      */
     public void testRemoveElement() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
-            assertTrue(q.contains(i));
-            assertTrue(q.remove(i));
-            assertFalse(q.contains(i));
-            assertTrue(q.contains(i-1));
-        }
-        for (int i = 0; i < SIZE; i+=2) {
-            assertTrue(q.contains(i));
-            assertTrue(q.remove(i));
-            assertFalse(q.contains(i));
-            assertFalse(q.remove(i+1));
-            assertFalse(q.contains(i+1));
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
+        for (int i = 1; i < SIZE; i += 2) {
+            mustContain(q, i);
+            mustRemove(q, i);
+            mustNotContain(q, i);
+            mustContain(q, i - 1);
+        }
+        for (int i = 0; i < SIZE; i += 2) {
+            mustContain(q, i);
+            mustRemove(q, i);
+            mustNotContain(q, i);
+            mustNotRemove(q, i + 1);
+            mustNotContain(q, i + 1);
         }
         assertTrue(q.isEmpty());
     }
@@ -305,11 +307,11 @@ public class ConcurrentLinkedQueueTest e
      * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<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);
         }
     }
 
@@ -317,10 +319,10 @@ public class ConcurrentLinkedQueueTest e
      * clear removes all elements
      */
     public void testClear() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         q.clear();
         assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
+        mustEqual(0, q.size());
         q.add(one);
         assertFalse(q.isEmpty());
         q.clear();
@@ -331,12 +333,12 @@ public class ConcurrentLinkedQueueTest e
      * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        ConcurrentLinkedQueue p = new ConcurrentLinkedQueue();
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> p = new ConcurrentLinkedQueue<Item>();
         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));
     }
@@ -345,8 +347,8 @@ public class ConcurrentLinkedQueueTest e
      * retainAll(c) retains only those elements of c and reports true if change
      */
     public void testRetainAll() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        ConcurrentLinkedQueue p = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> p = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             boolean changed = q.retainAll(p);
             if (i == 0)
@@ -355,7 +357,7 @@ public class ConcurrentLinkedQueueTest e
                 assertTrue(changed);
 
             assertTrue(q.containsAll(p));
-            assertEquals(SIZE-i, q.size());
+            mustEqual(SIZE - i, q.size());
             p.remove();
         }
     }
@@ -365,13 +367,13 @@ public class ConcurrentLinkedQueueTest e
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
-            ConcurrentLinkedQueue q = populatedQueue(SIZE);
-            ConcurrentLinkedQueue p = populatedQueue(i);
+            ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
+            ConcurrentLinkedQueue<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 I = (Integer)(p.remove());
-                assertFalse(q.contains(I));
+                Item x = p.remove();
+                assertFalse(q.contains(x));
             }
         }
     }
@@ -380,31 +382,34 @@ public class ConcurrentLinkedQueueTest e
      * toArray contains all elements in FIFO order
      */
     public void testToArray() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.poll());
+        ConcurrentLinkedQueue<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 in FIFO order
      */
     public void testToArray2() {
-        ConcurrentLinkedQueue<Integer> q = populatedQueue(SIZE);
-        Integer[] ints = new Integer[SIZE];
-        Integer[] array = q.toArray(ints);
-        assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.poll());
+        ConcurrentLinkedQueue<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
      */
     public void testToArray_NullArg() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         try {
-            q.toArray(null);
+            q.toArray((Object[])null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
@@ -413,7 +418,7 @@ public class ConcurrentLinkedQueueTest e
      * toArray(incompatible array type) throws ArrayStoreException
      */
     public void testToArray1_BadArg() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         try {
             q.toArray(new String[10]);
             shouldThrow();
@@ -424,59 +429,65 @@ public class ConcurrentLinkedQueueTest e
      * iterator iterates through all elements
      */
     public void testIterator() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        int i = 0;
-        Iterator it = q.iterator();
-        while (it.hasNext()) {
-            assertTrue(q.contains(it.next()));
-            ++i;
-        }
-        assertEquals(i, SIZE);
+        ConcurrentLinkedQueue<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);
+    }
+
+    /**
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(new ConcurrentLinkedQueue<Item>().iterator());
     }
 
     /**
      * iterator ordering is FIFO
      */
     public void testIteratorOrdering() {
-        final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        final ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         q.add(one);
         q.add(two);
         q.add(three);
 
         int k = 0;
-        for (Iterator it = q.iterator(); it.hasNext();) {
-            assertEquals(++k, it.next());
+        for (Iterator<? extends Item> it = q.iterator(); it.hasNext();) {
+            mustEqual(++k, it.next());
         }
 
-        assertEquals(3, k);
+        mustEqual(3, k);
     }
 
     /**
      * Modifications do not cause iterators to fail
      */
     public void testWeaklyConsistentIteration() {
-        final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        final ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         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("queue should be empty again", 0, q.size());
+        mustEqual(0, q.size());
     }
 
     /**
      * iterator.remove removes current element
      */
     public void testIteratorRemove() {
-        final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        final ConcurrentLinkedQueue<Item> q = new ConcurrentLinkedQueue<Item>();
         q.add(one);
         q.add(two);
         q.add(three);
-        Iterator it = q.iterator();
+        Iterator<? extends Item> it = q.iterator();
         it.next();
         it.remove();
         it = q.iterator();
@@ -489,7 +500,7 @@ public class ConcurrentLinkedQueueTest e
      * toString contains toStrings of elements
      */
     public void testToString() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        ConcurrentLinkedQueue<Item> q = populatedQueue(SIZE);
         String s = q.toString();
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(s.contains(String.valueOf(i)));
@@ -497,21 +508,35 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     * A deserialized serialized queue has same elements in same order
+     * A deserialized/reserialized queue has same elements in same order
      */
     public void testSerialization() throws Exception {
-        Queue x = populatedQueue(SIZE);
-        Queue y = serialClone(x);
+        Queue<Item> x = populatedQueue(SIZE);
+        Queue<Item> y = serialClone(x);
 
-        assertTrue(x != y);
-        assertEquals(x.size(), y.size());
-        assertEquals(x.toString(), y.toString());
+        assertNotSame(x, y);
+        mustEqual(x.size(), y.size());
+        mustEqual(x.toString(), y.toString());
         assertTrue(Arrays.equals(x.toArray(), y.toArray()));
         while (!x.isEmpty()) {
             assertFalse(y.isEmpty());
-            assertEquals(x.remove(), y.remove());
+            mustEqual(x.remove(), y.remove());
         }
         assertTrue(y.isEmpty());
     }
 
+    /**
+     * remove(null), contains(null) always return false
+     */
+    public void testNeverContainsNull() {
+        Collection<?>[] qs = {
+            new ConcurrentLinkedQueue<Object>(),
+            populatedQueue(2),
+        };
+
+        for (Collection<?> q : qs) {
+            assertFalse(q.contains(null));
+            assertFalse(q.remove(null));
+        }
+    }
 }