--- jsr166/src/test/tck/ConcurrentLinkedQueueTest.java	2003/09/20 18:20:07	1.4
+++ jsr166/src/test/tck/ConcurrentLinkedQueueTest.java	2015/05/15 18:21:19	1.38
@@ -1,100 +1,99 @@
 /*
- * Written by members of JCP JSR-166 Expert Group and released to the
- * public domain. Use, modify, and redistribute this code in any way
- * without acknowledgement. Other contributors include Andrew Wright,
- * Jeffrey Hayes, Pat Fischer, Mike Judd.
+ * 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/publicdomain/zero/1.0/
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
+ * Pat Fisher, Mike Judd.
  */
 
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
-import java.io.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
 
 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);
+        return new TestSuite(ConcurrentLinkedQueueTest.class);
     }
 
     /**
-     * Create a queue of given size containing consecutive
+     * Returns a new queue of given size containing consecutive
      * Integers 0 ... n.
      */
-    private ConcurrentLinkedQueue populatedQueue(int n) {
-        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+    private ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
+        ConcurrentLinkedQueue<Integer> q = new ConcurrentLinkedQueue<Integer>();
         assertTrue(q.isEmpty());
-	for(int i = 0; i < n; ++i)
-	    assertTrue(q.offer(new Integer(i)));
+        for (int i = 0; i < n; ++i)
+            assertTrue(q.offer(new Integer(i)));
         assertFalse(q.isEmpty());
-	assertEquals(n, q.size());
+        assertEquals(n, q.size());
         return q;
     }
- 
+
     /**
-     *
+     * new queue is empty
      */
     public void testConstructor1() {
         assertEquals(0, new ConcurrentLinkedQueue().size());
     }
 
     /**
-     *
+     * Initializing from null Collection throws NPE
      */
     public void testConstructor3() {
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
+            new ConcurrentLinkedQueue((Collection)null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Initializing from Collection of null elements throws NPE
      */
     public void testConstructor4() {
         try {
-            Integer[] ints = new Integer[SIZE];
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
+            new ConcurrentLinkedQueue(Arrays.asList(new Integer[SIZE]));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * 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] = new Integer(i);
         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(Arrays.asList(ints));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Queue contains all elements of collection used to initialize
      */
     public void testConstructor6() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            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());
-        }
-        finally {}
+        Integer[] ints = new Integer[SIZE];
+        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());
     }
 
     /**
-     *
+     * isEmpty is true before add, false after
      */
     public void testEmpty() {
         ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
@@ -108,7 +107,7 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * size changes when elements added and removed
      */
     public void testSize() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
@@ -123,18 +122,29 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * offer(null) throws NPE
      */
     public void testOfferNull() {
-	try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        try {
             q.offer(null);
             shouldThrow();
-        } catch (NullPointerException success) { }   
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * add(null) throws NPE
+     */
+    public void testAddNull() {
+        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        try {
+            q.add(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Offer returns true
      */
     public void testOffer() {
         ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
@@ -143,7 +153,7 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * add returns true
      */
     public void testAdd() {
         ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
@@ -154,134 +164,145 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * addAll(null) throws NPE
      */
     public void testAddAll1() {
+        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
             q.addAll(null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
+
+    /**
+     * addAll(this) throws IAE
+     */
+    public void testAddAllSelf() {
+        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        try {
+            q.addAll(q);
+            shouldThrow();
+        } catch (IllegalArgumentException success) {}
+    }
+
     /**
-     *
+     * addAll of a collection with null elements throws NPE
      */
     public void testAddAll2() {
+        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
         try {
-            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
-            Integer[] ints = new Integer[SIZE];
-            q.addAll(Arrays.asList(ints));
+            q.addAll(Arrays.asList(new Integer[SIZE]));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
+
     /**
-     *
+     * addAll of a collection with any null elements throws NPE after
+     * possibly adding some elements
      */
     public void testAddAll3() {
+        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE-1; ++i)
+            ints[i] = new Integer(i);
         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));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Queue contains all elements, in traversal order, of successful addAll
      */
     public void testAddAll5() {
-        try {
-            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();
-            assertFalse(q.addAll(Arrays.asList(empty)));
-            assertTrue(q.addAll(Arrays.asList(ints)));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+        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();
+        assertFalse(q.addAll(Arrays.asList(empty)));
+        assertTrue(q.addAll(Arrays.asList(ints)));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.poll());
     }
 
     /**
-     *
+     * poll succeeds unless empty
      */
     public void testPoll() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.poll()).intValue());
+            assertEquals(i, q.poll());
         }
-	assertNull(q.poll());
+        assertNull(q.poll());
     }
 
     /**
-     *
+     * peek returns next element, or null if empty
      */
     public void testPeek() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.peek()).intValue());
-            q.poll();
+            assertEquals(i, q.peek());
+            assertEquals(i, q.poll());
             assertTrue(q.peek() == null ||
-                       i != ((Integer)q.peek()).intValue());
+                       !q.peek().equals(i));
         }
-	assertNull(q.peek());
+        assertNull(q.peek());
     }
 
     /**
-     *
+     * element returns next element, or throws NSEE if empty
      */
     public void testElement() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.element()).intValue());
-            q.poll();
+            assertEquals(i, q.element());
+            assertEquals(i, q.poll());
         }
         try {
             q.element();
             shouldThrow();
-        }
-        catch (NoSuchElementException success) {}
+        } catch (NoSuchElementException success) {}
     }
 
     /**
-     *
+     * remove removes next element, or throws NSEE if empty
      */
     public void testRemove() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.remove()).intValue());
+            assertEquals(i, q.remove());
         }
         try {
             q.remove();
             shouldThrow();
-        } catch (NoSuchElementException success){
-	}   
+        } catch (NoSuchElementException success) {}
     }
 
     /**
-     *
+     * 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.remove(new Integer(i)));
-        }
-        for (int i = 0; i < SIZE; i+=2) {
-            assertTrue(q.remove(new Integer(i)));
-            assertFalse(q.remove(new Integer(i+1)));
+        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));
         }
         assertTrue(q.isEmpty());
     }
-	
+
     /**
-     *
+     * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
@@ -293,7 +314,7 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * clear removes all elements
      */
     public void testClear() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
@@ -307,7 +328,7 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
@@ -321,7 +342,7 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * retainAll(c) retains only those elements of c and reports true if change
      */
     public void testRetainAll() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
@@ -340,7 +361,7 @@ public class ConcurrentLinkedQueueTest e
     }
 
     /**
-     *
+     * removeAll(c) removes only those elements of c and reports true if changed
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
@@ -349,51 +370,78 @@ public class ConcurrentLinkedQueueTest e
             assertTrue(q.removeAll(p));
             assertEquals(SIZE-i, q.size());
             for (int j = 0; j < i; ++j) {
-                Integer I = (Integer)(p.remove());
-                assertFalse(q.contains(I));
+                Integer x = (Integer)(p.remove());
+                assertFalse(q.contains(x));
             }
         }
     }
 
     /**
-     *
+     * toArray contains all elements in FIFO order
      */
     public void testToArray() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
-	Object[] o = q.toArray();
-        Arrays.sort(o);
-	for(int i = 0; i < o.length; i++)
-	    assertEquals(o[i], q.poll());
+        Object[] o = q.toArray();
+        for (int i = 0; i < o.length; i++)
+            assertSame(o[i], q.poll());
     }
 
     /**
-     *
+     * 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());
+    }
+
+    /**
+     * toArray(null) throws NullPointerException
+     */
+    public void testToArray_NullArg() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
-	Integer[] ints = new Integer[SIZE];
-	ints = (Integer[])q.toArray(ints);
-        Arrays.sort(ints);
-        for(int i = 0; i < ints.length; i++)
-            assertEquals(ints[i], q.poll());
+        try {
+            q.toArray(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
-    
+
+    /**
+     * toArray(incompatible array type) throws ArrayStoreException
+     */
+    public void testToArray1_BadArg() {
+        ConcurrentLinkedQueue q = populatedQueue(SIZE);
+        try {
+            q.toArray(new String[10]);
+            shouldThrow();
+        } catch (ArrayStoreException success) {}
+    }
+
     /**
-     *
+     * iterator iterates through all elements
      */
     public void testIterator() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        int i = 0;
-	Iterator it = q.iterator();
-        while(it.hasNext()) {
+        Iterator it = q.iterator();
+        int i;
+        for (i = 0; it.hasNext(); i++)
             assertTrue(q.contains(it.next()));
-            ++i;
-        }
         assertEquals(i, SIZE);
+        assertIteratorExhausted(it);
     }
 
     /**
-     *
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(new ConcurrentLinkedQueue().iterator());
+    }
+
+    /**
+     * iterator ordering is FIFO
      */
     public void testIteratorOrdering() {
         final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
@@ -403,39 +451,33 @@ public class ConcurrentLinkedQueueTest e
 
         int k = 0;
         for (Iterator it = q.iterator(); it.hasNext();) {
-            int i = ((Integer)(it.next())).intValue();
-            assertEquals(++k, i);
+            assertEquals(++k, it.next());
         }
 
         assertEquals(3, k);
     }
 
     /**
-     *
+     * Modifications do not cause iterators to fail
      */
-    public void testWeaklyConsistentIteration () {
+    public void testWeaklyConsistentIteration() {
         final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
         q.add(one);
         q.add(two);
         q.add(three);
 
-        try {
-            for (Iterator it = q.iterator(); it.hasNext();) {
-                q.remove();
-                it.next();
-            }
-        }
-        catch (ConcurrentModificationException e) {
-            shouldThrow();
+        for (Iterator it = q.iterator(); it.hasNext();) {
+            q.remove();
+            it.next();
         }
 
         assertEquals("queue should be empty again", 0, q.size());
     }
 
     /**
-     *
+     * iterator.remove removes current element
      */
-    public void testIteratorRemove () {
+    public void testIteratorRemove() {
         final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
         q.add(one);
         q.add(two);
@@ -444,43 +486,52 @@ public class ConcurrentLinkedQueueTest e
         it.next();
         it.remove();
         it = q.iterator();
-        assertEquals(it.next(), two);
-        assertEquals(it.next(), three);
+        assertSame(it.next(), two);
+        assertSame(it.next(), three);
         assertFalse(it.hasNext());
     }
 
-
     /**
-     *
+     * toString contains toStrings of elements
      */
     public void testToString() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
         String s = q.toString();
         for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
+            assertTrue(s.contains(String.valueOf(i)));
         }
-    }        
+    }
 
     /**
-     *
+     * A deserialized serialized queue has same elements in same order
      */
-    public void testSerialization() {
-        ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        try {
-            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
-            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
-            out.writeObject(q);
-            out.close();
+    public void testSerialization() throws Exception {
+        Queue x = populatedQueue(SIZE);
+        Queue y = serialClone(x);
 
-            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
-            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
-            ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
-            assertEquals(q.size(), r.size());
-            while (!q.isEmpty()) 
-                assertEquals(q.remove(), r.remove());
-        } catch(Exception e){
-            unexpectedException();
+        assertNotSame(x, y);
+        assertEquals(x.size(), y.size());
+        assertEquals(x.toString(), y.toString());
+        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
+        while (!x.isEmpty()) {
+            assertFalse(y.isEmpty());
+            assertEquals(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));
+        }
+    }
 }