--- jsr166/src/test/tck/ArrayDequeTest.java	2009/11/21 20:34:59	1.11
+++ jsr166/src/test/tck/ArrayDequeTest.java	2014/12/31 20:09:08	1.31
@@ -1,16 +1,24 @@
 /*
  * 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/
  */
 
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Queue;
+import java.util.Random;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
 
 public class ArrayDequeTest extends JSR166TestCase {
     public static void main(String[] args) {
-        junit.textui.TestRunner.run (suite());
+        junit.textui.TestRunner.run(suite());
     }
 
     public static Test suite() {
@@ -18,11 +26,11 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * Create a queue of given size containing consecutive
+     * Returns a new deque of given size containing consecutive
      * Integers 0 ... n.
      */
-    private ArrayDeque populatedDeque(int n) {
-        ArrayDeque q = new ArrayDeque();
+    private ArrayDeque<Integer> populatedDeque(int n) {
+        ArrayDeque<Integer> q = new ArrayDeque<Integer>();
         assertTrue(q.isEmpty());
         for (int i = 0; i < n; ++i)
             assertTrue(q.offerLast(new Integer(i)));
@@ -32,7 +40,7 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * new queue is empty
+     * new deque is empty
      */
     public void testConstructor1() {
         assertEquals(0, new ArrayDeque().size());
@@ -49,8 +57,31 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * Queue contains all elements of collection used to initialize
+     * Initializing from Collection of null elements throws NPE
+     */
+    public void testConstructor4() {
+        try {
+            Integer[] ints = new Integer[SIZE];
+            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * Initializing from Collection with some null elements throws NPE
+     */
+    public void testConstructor5() {
+        try {
+            Integer[] ints = new Integer[SIZE];
+            for (int i = 0; i < SIZE-1; ++i)
+                ints[i] = new Integer(i);
+            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
 
+    /**
+     * Deque contains all elements of collection used to initialize
      */
     public void testConstructor6() {
         Integer[] ints = new Integer[SIZE];
@@ -102,22 +133,22 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * peekFirst returns element inserted with push
+     * peekFirst() returns element inserted with push
      */
     public void testPush() {
         ArrayDeque q = populatedDeque(3);
         q.pollLast();
         q.push(four);
-        assertEquals(four,q.peekFirst());
+        assertSame(four, q.peekFirst());
     }
 
     /**
-     *  pop removes next element, or throws NSEE if empty
+     * pop() removes next element, or throws NSEE if empty
      */
     public void testPop() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.pop()).intValue());
+            assertEquals(i, q.pop());
         }
         try {
             q.pop();
@@ -128,6 +159,17 @@ public class ArrayDequeTest extends JSR1
     /**
      * offer(null) throws NPE
      */
+    public void testOfferNull() {
+        try {
+            ArrayDeque q = new ArrayDeque();
+            q.offer(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * offerFirst(null) throws NPE
+     */
     public void testOfferFirstNull() {
         try {
             ArrayDeque q = new ArrayDeque();
@@ -137,32 +179,113 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * OfferFirst succeeds
+     * offerLast(null) throws NPE
+     */
+    public void testOfferLastNull() {
+        try {
+            ArrayDeque q = new ArrayDeque();
+            q.offerLast(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * offer(x) succeeds
+     */
+    public void testOffer() {
+        ArrayDeque q = new ArrayDeque();
+        assertTrue(q.offer(zero));
+        assertTrue(q.offer(one));
+        assertSame(zero, q.peekFirst());
+        assertSame(one, q.peekLast());
+    }
+
+    /**
+     * offerFirst(x) succeeds
      */
     public void testOfferFirst() {
         ArrayDeque q = new ArrayDeque();
-        assertTrue(q.offerFirst(new Integer(0)));
-        assertTrue(q.offerFirst(new Integer(1)));
+        assertTrue(q.offerFirst(zero));
+        assertTrue(q.offerFirst(one));
+        assertSame(one, q.peekFirst());
+        assertSame(zero, q.peekLast());
     }
 
     /**
-     * OfferLast succeeds
+     * offerLast(x) succeeds
      */
     public void testOfferLast() {
         ArrayDeque q = new ArrayDeque();
-        assertTrue(q.offerLast(new Integer(0)));
-        assertTrue(q.offerLast(new Integer(1)));
+        assertTrue(q.offerLast(zero));
+        assertTrue(q.offerLast(one));
+        assertSame(zero, q.peekFirst());
+        assertSame(one, q.peekLast());
     }
 
     /**
-     * add succeeds
+     * add(null) throws NPE
+     */
+    public void testAddNull() {
+        try {
+            ArrayDeque q = new ArrayDeque();
+            q.add(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * addFirst(null) throws NPE
+     */
+    public void testAddFirstNull() {
+        try {
+            ArrayDeque q = new ArrayDeque();
+            q.addFirst(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * addLast(null) throws NPE
+     */
+    public void testAddLastNull() {
+        try {
+            ArrayDeque q = new ArrayDeque();
+            q.addLast(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * add(x) succeeds
      */
     public void testAdd() {
         ArrayDeque q = new ArrayDeque();
-        for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, q.size());
-            assertTrue(q.add(new Integer(i)));
-        }
+        assertTrue(q.add(zero));
+        assertTrue(q.add(one));
+        assertSame(zero, q.peekFirst());
+        assertSame(one, q.peekLast());
+    }
+
+    /**
+     * addFirst(x) succeeds
+     */
+    public void testAddFirst() {
+        ArrayDeque q = new ArrayDeque();
+        q.addFirst(zero);
+        q.addFirst(one);
+        assertSame(one, q.peekFirst());
+        assertSame(zero, q.peekLast());
+    }
+
+    /**
+     * addLast(x) succeeds
+     */
+    public void testAddLast() {
+        ArrayDeque q = new ArrayDeque();
+        q.addLast(zero);
+        q.addLast(one);
+        assertSame(zero, q.peekFirst());
+        assertSame(one, q.peekLast());
     }
 
     /**
@@ -177,7 +300,34 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * Queue contains all elements, in traversal order, of successful addAll
+     * addAll of a collection with null elements throws NPE
+     */
+    public void testAddAll2() {
+        try {
+            ArrayDeque q = new ArrayDeque();
+            Integer[] ints = new Integer[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() {
+        try {
+            ArrayDeque q = new ArrayDeque();
+            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) {}
+    }
+
+    /**
+     * Deque contains all elements, in traversal order, of successful addAll
      */
     public void testAddAll5() {
         Integer[] empty = new Integer[0];
@@ -192,45 +342,45 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  pollFirst succeeds unless empty
+     * pollFirst() succeeds unless empty
      */
     public void testPollFirst() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.pollFirst()).intValue());
+            assertEquals(i, q.pollFirst());
         }
         assertNull(q.pollFirst());
     }
 
     /**
-     *  pollLast succeeds unless empty
+     * pollLast() succeeds unless empty
      */
     public void testPollLast() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = SIZE-1; i >= 0; --i) {
-            assertEquals(i, ((Integer)q.pollLast()).intValue());
+            assertEquals(i, q.pollLast());
         }
         assertNull(q.pollLast());
     }
 
     /**
-     *  poll succeeds unless empty
+     * poll() succeeds unless empty
      */
     public void testPoll() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.poll()).intValue());
+            assertEquals(i, q.poll());
         }
         assertNull(q.poll());
     }
 
     /**
-     *  remove removes next element, or throws NSEE if empty
+     * remove() removes next element, or throws NSEE if empty
      */
     public void testRemove() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.remove()).intValue());
+            assertEquals(i, q.remove());
         }
         try {
             q.remove();
@@ -239,55 +389,91 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  peekFirst returns next element, or null if empty
+     * remove(x) removes x and returns true if present
+     */
+    public void testRemoveElement() {
+        ArrayDeque q = populatedDeque(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));
+        }
+        assertTrue(q.isEmpty());
+    }
+
+    /**
+     * peekFirst() returns next element, or null if empty
      */
     public void testPeekFirst() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.peekFirst()).intValue());
-            q.pollFirst();
+            assertEquals(i, q.peekFirst());
+            assertEquals(i, q.pollFirst());
             assertTrue(q.peekFirst() == null ||
-                       i != ((Integer)q.peekFirst()).intValue());
+                       !q.peekFirst().equals(i));
         }
         assertNull(q.peekFirst());
     }
 
     /**
-     *  peek returns next element, or null if empty
+     * peek() returns next element, or null if empty
      */
     public void testPeek() {
         ArrayDeque q = populatedDeque(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());
     }
 
     /**
-     *  peekLast returns next element, or null if empty
+     * peekLast() returns next element, or null if empty
      */
     public void testPeekLast() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = SIZE-1; i >= 0; --i) {
-            assertEquals(i, ((Integer)q.peekLast()).intValue());
-            q.pollLast();
+            assertEquals(i, q.peekLast());
+            assertEquals(i, q.pollLast());
             assertTrue(q.peekLast() == null ||
-                       i != ((Integer)q.peekLast()).intValue());
+                       !q.peekLast().equals(i));
         }
         assertNull(q.peekLast());
     }
 
     /**
-     * getFirst returns next getFirst, or throws NSEE if empty
+     * element() returns first element, or throws NSEE if empty
+     */
+    public void testElement() {
+        ArrayDeque q = populatedDeque(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            assertEquals(i, q.element());
+            assertEquals(i, q.poll());
+        }
+        try {
+            q.element();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
+    }
+
+    /**
+     * getFirst() returns first element, or throws NSEE if empty
      */
     public void testFirstElement() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.getFirst()).intValue());
-            q.pollFirst();
+            assertEquals(i, q.getFirst());
+            assertEquals(i, q.pollFirst());
         }
         try {
             q.getFirst();
@@ -296,13 +482,13 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  getLast returns next element, or throws NSEE if empty
+     * getLast() returns last element, or throws NSEE if empty
      */
     public void testLastElement() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = SIZE-1; i >= 0; --i) {
-            assertEquals(i, ((Integer)q.getLast()).intValue());
-            q.pollLast();
+            assertEquals(i, q.getLast());
+            assertEquals(i, q.pollLast());
         }
         try {
             q.getLast();
@@ -311,19 +497,34 @@ public class ArrayDequeTest extends JSR1
         assertNull(q.peekLast());
     }
 
-
     /**
-     *  removeFirst removes next element, or throws NSEE if empty
+     * removeFirst() removes first element, or throws NSEE if empty
      */
     public void testRemoveFirst() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.removeFirst()).intValue());
+            assertEquals(i, q.removeFirst());
         }
         try {
             q.removeFirst();
             shouldThrow();
         } catch (NoSuchElementException success) {}
+        assertNull(q.peekFirst());
+    }
+
+    /**
+     * removeLast() removes last element, or throws NSEE if empty
+     */
+    public void testRemoveLast() {
+        ArrayDeque q = populatedDeque(SIZE);
+        for (int i = SIZE - 1; i >= 0; --i) {
+            assertEquals(i, q.removeLast());
+        }
+        try {
+            q.removeLast();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
+        assertNull(q.peekLast());
     }
 
     /**
@@ -331,10 +532,10 @@ public class ArrayDequeTest extends JSR1
      */
     public void testRemoveFirstOccurrence() {
         ArrayDeque q = populatedDeque(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
+        for (int i = 1; i < SIZE; i += 2) {
             assertTrue(q.removeFirstOccurrence(new Integer(i)));
         }
-        for (int i = 0; i < SIZE; i+=2) {
+        for (int i = 0; i < SIZE; i += 2) {
             assertTrue(q.removeFirstOccurrence(new Integer(i)));
             assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
         }
@@ -346,10 +547,10 @@ public class ArrayDequeTest extends JSR1
      */
     public void testRemoveLastOccurrence() {
         ArrayDeque q = populatedDeque(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
+        for (int i = 1; i < SIZE; i += 2) {
             assertTrue(q.removeLastOccurrence(new Integer(i)));
         }
-        for (int i = 0; i < SIZE; i+=2) {
+        for (int i = 0; i < SIZE; i += 2) {
             assertTrue(q.removeLastOccurrence(new Integer(i)));
             assertFalse(q.removeLastOccurrence(new Integer(i+1)));
         }
@@ -363,7 +564,7 @@ public class ArrayDequeTest extends JSR1
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.contains(new Integer(i)));
-            q.pollFirst();
+            assertEquals(i, q.pollFirst());
             assertFalse(q.contains(new Integer(i)));
         }
     }
@@ -376,7 +577,7 @@ public class ArrayDequeTest extends JSR1
         q.clear();
         assertTrue(q.isEmpty());
         assertEquals(0, q.size());
-        q.add(new Integer(1));
+        assertTrue(q.add(new Integer(1)));
         assertFalse(q.isEmpty());
         q.clear();
         assertTrue(q.isEmpty());
@@ -391,7 +592,7 @@ public class ArrayDequeTest extends JSR1
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
-            p.add(new Integer(i));
+            assertTrue(p.add(new Integer(i)));
         }
         assertTrue(p.containsAll(q));
     }
@@ -404,11 +605,7 @@ public class ArrayDequeTest extends JSR1
         ArrayDeque p = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             boolean changed = q.retainAll(p);
-            if (i == 0)
-                assertFalse(changed);
-            else
-                assertTrue(changed);
-
+            assertEquals(changed, (i > 0));
             assertTrue(q.containsAll(p));
             assertEquals(SIZE-i, q.size());
             p.removeFirst();
@@ -425,61 +622,123 @@ public class ArrayDequeTest extends JSR1
             assertTrue(q.removeAll(p));
             assertEquals(SIZE-i, q.size());
             for (int j = 0; j < i; ++j) {
-                Integer I = (Integer)(p.removeFirst());
-                assertFalse(q.contains(I));
+                assertFalse(q.contains(p.removeFirst()));
             }
         }
     }
 
+    void checkToArray(ArrayDeque q) {
+        int size = q.size();
+        Object[] o = q.toArray();
+        assertEquals(size, o.length);
+        Iterator it = q.iterator();
+        for (int i = 0; i < size; i++) {
+            Integer x = (Integer) it.next();
+            assertEquals((Integer)o[0] + i, (int) x);
+            assertSame(o[i], x);
+        }
+    }
+
     /**
-     *  toArray contains all elements
+     * toArray() contains all elements in FIFO order
      */
     public void testToArray() {
-        ArrayDeque q = populatedDeque(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertEquals(o[i], q.pollFirst());
+        ArrayDeque q = new ArrayDeque();
+        for (int i = 0; i < SIZE; i++) {
+            checkToArray(q);
+            q.addLast(i);
+        }
+        // Provoke wraparound
+        for (int i = 0; i < SIZE; i++) {
+            checkToArray(q);
+            assertEquals(i, q.poll());
+            q.addLast(SIZE+i);
+        }
+        for (int i = 0; i < SIZE; i++) {
+            checkToArray(q);
+            assertEquals(SIZE+i, q.poll());
+        }
+    }
+
+    void checkToArray2(ArrayDeque q) {
+        int size = q.size();
+        Integer[] a1 = size == 0 ? null : new Integer[size-1];
+        Integer[] a2 = new Integer[size];
+        Integer[] a3 = new Integer[size+2];
+        if (size > 0) Arrays.fill(a1, 42);
+        Arrays.fill(a2, 42);
+        Arrays.fill(a3, 42);
+        Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
+        Integer[] b2 = (Integer[]) q.toArray(a2);
+        Integer[] b3 = (Integer[]) q.toArray(a3);
+        assertSame(a2, b2);
+        assertSame(a3, b3);
+        Iterator it = q.iterator();
+        for (int i = 0; i < size; i++) {
+            Integer x = (Integer) it.next();
+            assertSame(b1[i], x);
+            assertEquals(b1[0] + i, (int) x);
+            assertSame(b2[i], x);
+            assertSame(b3[i], x);
+        }
+        assertNull(a3[size]);
+        assertEquals(42, (int) a3[size+1]);
+        if (size > 0) {
+            assertNotSame(a1, b1);
+            assertEquals(size, b1.length);
+            for (int i = 0; i < a1.length; i++) {
+                assertEquals(42, (int) a1[i]);
+            }
+        }
     }
 
     /**
-     *  toArray(a) contains all elements
+     * toArray(a) contains all elements in FIFO order
      */
     public void testToArray2() {
-        ArrayDeque q = populatedDeque(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.pollFirst());
+        ArrayDeque q = new ArrayDeque();
+        for (int i = 0; i < SIZE; i++) {
+            checkToArray2(q);
+            q.addLast(i);
+        }
+        // Provoke wraparound
+        for (int i = 0; i < SIZE; i++) {
+            checkToArray2(q);
+            assertEquals(i, q.poll());
+            q.addLast(SIZE+i);
+        }
+        for (int i = 0; i < SIZE; i++) {
+            checkToArray2(q);
+            assertEquals(SIZE+i, q.poll());
+        }
     }
 
     /**
-     * toArray(null) throws NPE
+     * toArray(null) throws NullPointerException
      */
-    public void testToArray_BadArg() {
+    public void testToArray_NullArg() {
+        ArrayDeque l = new ArrayDeque();
+        l.add(new Object());
         try {
-            ArrayDeque l = new ArrayDeque();
-            l.add(new Object());
-            Object o[] = l.toArray(null);
+            l.toArray(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
 
     /**
-     * toArray with incompatable aray type throws CCE
+     * toArray(incompatible array type) throws ArrayStoreException
      */
     public void testToArray1_BadArg() {
+        ArrayDeque l = new ArrayDeque();
+        l.add(new Integer(5));
         try {
-            ArrayDeque l = new ArrayDeque();
-            l.add(new Integer(5));
-            Object o[] = l.toArray(new String[10] );
+            l.toArray(new String[10]);
             shouldThrow();
         } catch (ArrayStoreException success) {}
     }
 
     /**
-     *  iterator iterates through all elements
+     * Iterator iterates through all elements
      */
     public void testIterator() {
         ArrayDeque q = populatedDeque(SIZE);
@@ -493,26 +752,25 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  iterator ordering is FIFO
+     * Iterator ordering is FIFO
      */
     public void testIteratorOrdering() {
         final ArrayDeque q = new ArrayDeque();
-        q.add(new Integer(1));
-        q.add(new Integer(2));
-        q.add(new Integer(3));
+        q.add(one);
+        q.add(two);
+        q.add(three);
         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);
     }
 
     /**
-     * iterator.remove removes current element
+     * iterator.remove() removes current element
      */
-    public void testIteratorRemove () {
+    public void testIteratorRemove() {
         final ArrayDeque q = new ArrayDeque();
         final Random rng = new Random();
         for (int iters = 0; iters < 100; ++iters) {
@@ -538,7 +796,7 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  Descending iterator iterates through all elements
+     * Descending iterator iterates through all elements
      */
     public void testDescendingIterator() {
         ArrayDeque q = populatedDeque(SIZE);
@@ -557,7 +815,7 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  Descending iterator ordering is reverse FIFO
+     * Descending iterator ordering is reverse FIFO
      */
     public void testDescendingIteratorOrdering() {
         final ArrayDeque q = new ArrayDeque();
@@ -567,8 +825,7 @@ public class ArrayDequeTest extends JSR1
             q.add(new Integer(1));
             int k = 0;
             for (Iterator it = q.descendingIterator(); it.hasNext();) {
-                int i = ((Integer)(it.next())).intValue();
-                assertEquals(++k, i);
+                assertEquals(++k, it.next());
             }
 
             assertEquals(3, k);
@@ -579,9 +836,9 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * descendingIterator.remove removes current element
+     * descendingIterator.remove() removes current element
      */
-    public void testDescendingIteratorRemove () {
+    public void testDescendingIteratorRemove() {
         final ArrayDeque q = new ArrayDeque();
         final Random rng = new Random();
         for (int iters = 0; iters < 100; ++iters) {
@@ -606,34 +863,50 @@ public class ArrayDequeTest extends JSR1
         }
     }
 
-
     /**
-     * toString contains toStrings of elements
+     * toString() contains toStrings of elements
      */
     public void testToString() {
         ArrayDeque q = populatedDeque(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)));
         }
     }
 
     /**
-     * peekFirst returns element inserted with addFirst
+     * A deserialized serialized deque has same elements in same order
      */
-    public void testAddFirst() {
-        ArrayDeque q = populatedDeque(3);
-        q.addFirst(four);
-        assertEquals(four,q.peekFirst());
+    public void testSerialization() throws Exception {
+        Queue x = populatedDeque(SIZE);
+        Queue y = serialClone(x);
+
+        assertNotSame(y, x);
+        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());
     }
 
     /**
-     * peekLast returns element inserted with addLast
+     * remove(null), contains(null) always return false
      */
-    public void testAddLast() {
-        ArrayDeque q = populatedDeque(3);
-        q.addLast(four);
-        assertEquals(four,q.peekLast());
+    public void testNeverContainsNull() {
+        Deque<?>[] qs = {
+            new ArrayDeque<Object>(),
+            populatedDeque(2),
+        };
+
+        for (Deque<?> q : qs) {
+            assertFalse(q.contains(null));
+            assertFalse(q.remove(null));
+            assertFalse(q.removeFirstOccurrence(null));
+            assertFalse(q.removeLastOccurrence(null));
+        }
     }
 
 }