--- jsr166/src/test/tck/ArrayDequeTest.java	2009/12/23 00:49:44	1.15
+++ jsr166/src/test/tck/ArrayDequeTest.java	2016/10/10 14:18:06	1.39
@@ -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());
+        main(suite(), args);
     }
 
     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());
@@ -43,14 +51,36 @@ public class ArrayDequeTest extends JSR1
      */
     public void testConstructor3() {
         try {
-            ArrayDeque q = new ArrayDeque((Collection)null);
+            new ArrayDeque((Collection)null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
 
     /**
-     * Queue contains all elements of collection used to initialize
+     * Initializing from Collection of null elements throws NPE
+     */
+    public void testConstructor4() {
+        try {
+            new ArrayDeque(Arrays.asList(new Integer[SIZE]));
+            shouldThrow();
+        } 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 {
+            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];
@@ -81,7 +111,7 @@ public class ArrayDequeTest extends JSR1
     public void testSize() {
         ArrayDeque q = populatedDeque(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(SIZE-i, q.size());
+            assertEquals(SIZE - i, q.size());
             q.removeFirst();
         }
         for (int i = 0; i < SIZE; ++i) {
@@ -94,15 +124,15 @@ public class ArrayDequeTest extends JSR1
      * push(null) throws NPE
      */
     public void testPushNull() {
+        ArrayDeque q = new ArrayDeque(1);
         try {
-            ArrayDeque q = new ArrayDeque(1);
             q.push(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
 
     /**
-     * peekFirst returns element inserted with push
+     * peekFirst() returns element inserted with push
      */
     public void testPush() {
         ArrayDeque q = populatedDeque(3);
@@ -112,7 +142,7 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  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);
@@ -128,56 +158,174 @@ public class ArrayDequeTest extends JSR1
     /**
      * offer(null) throws NPE
      */
+    public void testOfferNull() {
+        ArrayDeque q = new ArrayDeque();
+        try {
+            q.offer(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * offerFirst(null) throws NPE
+     */
     public void testOfferFirstNull() {
+        ArrayDeque q = new ArrayDeque();
         try {
-            ArrayDeque q = new ArrayDeque();
             q.offerFirst(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
 
     /**
-     * OfferFirst succeeds
+     * offerLast(null) throws NPE
+     */
+    public void testOfferLastNull() {
+        ArrayDeque q = new ArrayDeque();
+        try {
+            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() {
+        ArrayDeque q = new ArrayDeque();
+        try {
+            q.add(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * addFirst(null) throws NPE
+     */
+    public void testAddFirstNull() {
+        ArrayDeque q = new ArrayDeque();
+        try {
+            q.addFirst(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * addLast(null) throws NPE
+     */
+    public void testAddLastNull() {
+        ArrayDeque q = new ArrayDeque();
+        try {
+            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());
     }
 
     /**
      * addAll(null) throws NPE
      */
     public void testAddAll1() {
+        ArrayDeque q = new ArrayDeque();
         try {
-            ArrayDeque q = new ArrayDeque();
             q.addAll(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
 
     /**
-     * Queue contains all elements, in traversal order, of successful addAll
+     * addAll of a collection with null elements throws NPE
+     */
+    public void testAddAll2() {
+        ArrayDeque q = new ArrayDeque();
+        try {
+            q.addAll(Arrays.asList(new Integer[SIZE]));
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * addAll of a collection with any null elements throws NPE after
+     * possibly adding some elements
+     */
+    public void testAddAll3() {
+        ArrayDeque q = new ArrayDeque();
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE - 1; ++i)
+            ints[i] = new Integer(i);
+        try {
+            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,7 +340,7 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  pollFirst succeeds unless empty
+     * pollFirst() succeeds unless empty
      */
     public void testPollFirst() {
         ArrayDeque q = populatedDeque(SIZE);
@@ -203,18 +351,18 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  pollLast succeeds unless empty
+     * pollLast() succeeds unless empty
      */
     public void testPollLast() {
         ArrayDeque q = populatedDeque(SIZE);
-        for (int i = SIZE-1; i >= 0; --i) {
+        for (int i = SIZE - 1; i >= 0; --i) {
             assertEquals(i, q.pollLast());
         }
         assertNull(q.pollLast());
     }
 
     /**
-     *  poll succeeds unless empty
+     * poll() succeeds unless empty
      */
     public void testPoll() {
         ArrayDeque q = populatedDeque(SIZE);
@@ -225,7 +373,7 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  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);
@@ -239,7 +387,28 @@ 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);
@@ -253,7 +422,7 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  peek returns next element, or null if empty
+     * peek() returns next element, or null if empty
      */
     public void testPeek() {
         ArrayDeque q = populatedDeque(SIZE);
@@ -267,11 +436,11 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     *  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) {
+        for (int i = SIZE - 1; i >= 0; --i) {
             assertEquals(i, q.peekLast());
             assertEquals(i, q.pollLast());
             assertTrue(q.peekLast() == null ||
@@ -281,7 +450,22 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * 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);
@@ -296,11 +480,11 @@ 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) {
+        for (int i = SIZE - 1; i >= 0; --i) {
             assertEquals(i, q.getLast());
             assertEquals(i, q.pollLast());
         }
@@ -311,9 +495,8 @@ 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);
@@ -324,6 +507,22 @@ public class ArrayDequeTest extends JSR1
             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,14 +530,20 @@ public class ArrayDequeTest extends JSR1
      */
     public void testRemoveFirstOccurrence() {
         ArrayDeque q = populatedDeque(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
+        assertFalse(q.removeFirstOccurrence(null));
+        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)));
+            assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
         }
         assertTrue(q.isEmpty());
+        assertFalse(q.removeFirstOccurrence(null));
+        assertFalse(q.removeFirstOccurrence(42));
+        q = new ArrayDeque();
+        assertFalse(q.removeFirstOccurrence(null));
+        assertFalse(q.removeFirstOccurrence(42));
     }
 
     /**
@@ -346,14 +551,20 @@ public class ArrayDequeTest extends JSR1
      */
     public void testRemoveLastOccurrence() {
         ArrayDeque q = populatedDeque(SIZE);
-        for (int i = 1; i < SIZE; i+=2) {
+        assertFalse(q.removeLastOccurrence(null));
+        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)));
+            assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
         }
         assertTrue(q.isEmpty());
+        assertFalse(q.removeLastOccurrence(null));
+        assertFalse(q.removeLastOccurrence(42));
+        q = new ArrayDeque();
+        assertFalse(q.removeLastOccurrence(null));
+        assertFalse(q.removeLastOccurrence(42));
     }
 
     /**
@@ -406,7 +617,7 @@ public class ArrayDequeTest extends JSR1
             boolean changed = q.retainAll(p);
             assertEquals(changed, (i > 0));
             assertTrue(q.containsAll(p));
-            assertEquals(SIZE-i, q.size());
+            assertEquals(SIZE - i, q.size());
             p.removeFirst();
         }
     }
@@ -419,82 +630,153 @@ public class ArrayDequeTest extends JSR1
             ArrayDeque q = populatedDeque(SIZE);
             ArrayDeque p = populatedDeque(i);
             assertTrue(q.removeAll(p));
-            assertEquals(SIZE-i, q.size());
+            assertEquals(SIZE - i, q.size());
             for (int j = 0; j < i; ++j) {
                 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 {
-            Object o[] = l.toArray(null);
+            l.toArray(null);
             shouldThrow();
         } catch (NullPointerException success) {}
     }
 
     /**
-     * toArray with incompatible array type throws CCE
+     * toArray(incompatible array type) throws ArrayStoreException
      */
     public void testToArray1_BadArg() {
         ArrayDeque l = new ArrayDeque();
         l.add(new Integer(5));
         try {
-            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);
-        int i = 0;
         Iterator it = q.iterator();
-        while (it.hasNext()) {
+        int i;
+        for (i = 0; it.hasNext(); i++)
             assertTrue(q.contains(it.next()));
-            ++i;
-        }
         assertEquals(i, SIZE);
+        assertIteratorExhausted(it);
     }
 
     /**
-     *  iterator ordering is FIFO
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        Deque c = new ArrayDeque();
+        assertIteratorExhausted(c.iterator());
+        assertIteratorExhausted(c.descendingIterator());
+    }
+
+    /**
+     * 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();) {
             assertEquals(++k, it.next());
@@ -504,25 +786,25 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
-     * 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) {
             int max = rng.nextInt(5) + 2;
-            int split = rng.nextInt(max-1) + 1;
+            int split = rng.nextInt(max - 1) + 1;
             for (int j = 1; j <= max; ++j)
                 q.add(new Integer(j));
             Iterator it = q.iterator();
             for (int j = 1; j <= split; ++j)
                 assertEquals(it.next(), new Integer(j));
             it.remove();
-            assertEquals(it.next(), new Integer(split+1));
+            assertEquals(it.next(), new Integer(split + 1));
             for (int j = 1; j <= split; ++j)
                 q.remove(new Integer(j));
             it = q.iterator();
-            for (int j = split+1; j <= max; ++j) {
+            for (int j = split + 1; j <= max; ++j) {
                 assertEquals(it.next(), new Integer(j));
                 it.remove();
             }
@@ -532,7 +814,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);
@@ -551,7 +833,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();
@@ -572,25 +854,25 @@ 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) {
             int max = rng.nextInt(5) + 2;
-            int split = rng.nextInt(max-1) + 1;
+            int split = rng.nextInt(max - 1) + 1;
             for (int j = max; j >= 1; --j)
                 q.add(new Integer(j));
             Iterator it = q.descendingIterator();
             for (int j = 1; j <= split; ++j)
                 assertEquals(it.next(), new Integer(j));
             it.remove();
-            assertEquals(it.next(), new Integer(split+1));
+            assertEquals(it.next(), new Integer(split + 1));
             for (int j = 1; j <= split; ++j)
                 q.remove(new Integer(j));
             it = q.descendingIterator();
-            for (int j = split+1; j <= max; ++j) {
+            for (int j = split + 1; j <= max; ++j) {
                 assertEquals(it.next(), new Integer(j));
                 it.remove();
             }
@@ -599,34 +881,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);
-        assertSame(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);
-        assertSame(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));
+        }
     }
 
 }