--- jsr166/src/test/tck/ArrayDequeTest.java	2004/12/28 16:15:59	1.1
+++ jsr166/src/test/tck/ArrayDequeTest.java	2010/11/18 20:21:53	1.21
@@ -5,34 +5,39 @@
  */
 
 import junit.framework.*;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.util.*;
-import java.util.concurrent.*;
 
 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() {
-	return new TestSuite(ArrayDequeTest.class);
+        return new TestSuite(ArrayDequeTest.class);
     }
 
     /**
-     * Create a queue of given size containing consecutive
+     * Create a 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)));
+        for (int i = 0; i < n; ++i)
+            assertTrue(q.offerLast(new Integer(i)));
         assertFalse(q.isEmpty());
-	assertEquals(n, q.size());
+        assertEquals(n, q.size());
         return q;
     }
- 
+
     /**
-     * new queue is empty
+     * new deque is empty
      */
     public void testConstructor1() {
         assertEquals(0, new ArrayDeque().size());
@@ -45,24 +50,43 @@ public class ArrayDequeTest extends JSR1
         try {
             ArrayDeque q = new ArrayDeque((Collection)null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * 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 testConstructor6() {
+    public void testConstructor5() {
         try {
             Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
+            for (int i = 0; i < SIZE-1; ++i)
                 ints[i] = new Integer(i);
             ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.pollFirst());
-        }
-        finally {}
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * Deque contains all elements of collection used to initialize
+     */
+    public void testConstructor6() {
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = new Integer(i);
+        ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.pollFirst());
     }
 
     /**
@@ -98,77 +122,167 @@ public class ArrayDequeTest extends JSR1
      * push(null) throws NPE
      */
     public void testPushNull() {
-	try {
+        try {
             ArrayDeque q = new ArrayDeque(1);
             q.push(null);
             shouldThrow();
-        } catch (NullPointerException success) { }   
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * 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());
-    }	
+        q.push(four);
+        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();
             shouldThrow();
-        } catch (NoSuchElementException success){
-	}   
+        } catch (NoSuchElementException success) {}
     }
 
     /**
      * 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 {
+        try {
             ArrayDeque q = new ArrayDeque();
             q.offerFirst(null);
             shouldThrow();
-        } catch (NullPointerException success) { 
-        }   
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * 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(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) {}
     }
 
     /**
-     * add succeeds
+     * 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());
     }
 
     /**
@@ -179,165 +293,236 @@ public class ArrayDequeTest extends JSR1
             ArrayDeque q = new ArrayDeque();
             q.addAll(null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * Queue contains all elements, in traversal order, of successful addAll
+     * addAll of a collection with null elements throws NPE
      */
-    public void testAddAll5() {
+    public void testAddAll2() {
         try {
-            Integer[] empty = new Integer[0];
+            ArrayDeque q = new ArrayDeque();
             Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
+            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();
-            assertFalse(q.addAll(Arrays.asList(empty)));
-            assertTrue(q.addAll(Arrays.asList(ints)));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.pollFirst());
-        }
-        finally {}
+            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];
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = new Integer(i);
+        ArrayDeque q = new ArrayDeque();
+        assertFalse(q.addAll(Arrays.asList(empty)));
+        assertTrue(q.addAll(Arrays.asList(ints)));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.pollFirst());
     }
 
     /**
-     *  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());
+        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());
+        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());
+        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();
             shouldThrow();
-        } catch (NoSuchElementException success){
-	}   
+        } catch (NoSuchElementException success) {}
     }
 
     /**
-     *  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());
+        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());
+        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());
+    }
+
+    /**
+     * 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());
         }
-	assertNull(q.peekLast());
+        try {
+            q.element();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
     }
 
     /**
-     * getFirst returns next getFirst, or throws NSEE if empty
+     * 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();
             shouldThrow();
-        }
-        catch (NoSuchElementException success) {}
+        } catch (NoSuchElementException success) {}
     }
 
     /**
-     *  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();
             shouldThrow();
-        }
-        catch (NoSuchElementException success) {}
-	assertNull(q.peekLast());
+        } catch (NoSuchElementException success) {}
+        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){
-	}   
+        } 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());
     }
 
     /**
@@ -377,7 +562,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)));
         }
     }
@@ -390,7 +575,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());
@@ -405,7 +590,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));
     }
@@ -418,11 +603,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();
@@ -439,67 +620,65 @@ 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()));
             }
         }
     }
 
     /**
-     *  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());
+        Object[] o = q.toArray();
+        for (int i = 0; i < o.length; i++)
+            assertSame(o[i], q.pollFirst());
     }
 
     /**
-     *  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<Integer> q = populatedDeque(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.remove());
     }
 
     /**
-     * toArray(null) throws NPE
+     * toArray(null) throws NullPointerException
      */
-    public void testToArray_BadArg() {
-	try {
-	    ArrayDeque l = new ArrayDeque();
-	    l.add(new Object());
-	    Object o[] = l.toArray(null);
-	    shouldThrow();
-	} catch(NullPointerException success){}
+    public void testToArray_NullArg() {
+        ArrayDeque l = new ArrayDeque();
+        l.add(new Object());
+        try {
+            l.toArray(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * toArray with incompatable aray type throws CCE
+     * toArray(incompatible array type) throws ArrayStoreException
      */
     public void testToArray1_BadArg() {
-	try {
-	    ArrayDeque l = new ArrayDeque();
-	    l.add(new Integer(5));
-	    Object o[] = l.toArray(new String[10] );
-	    shouldThrow();
-	} catch(ArrayStoreException  success){}
+        ArrayDeque l = new ArrayDeque();
+        l.add(new Integer(5));
+        try {
+            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()) {
+        Iterator it = q.iterator();
+        while (it.hasNext()) {
             assertTrue(q.contains(it.next()));
             ++i;
         }
@@ -507,42 +686,120 @@ 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();
-        q.add(new Integer(1));
-        q.add(new Integer(2));
-        q.add(new Integer(3));
-        Iterator it = q.iterator();
-        it.next();
-        it.remove();
-        it = q.iterator();
-        assertEquals(it.next(), new Integer(2));
-        assertEquals(it.next(), new Integer(3));
+        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;
+            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));
+            for (int j = 1; j <= split; ++j)
+                q.remove(new Integer(j));
+            it = q.iterator();
+            for (int j = split+1; j <= max; ++j) {
+                assertEquals(it.next(), new Integer(j));
+                it.remove();
+            }
+            assertFalse(it.hasNext());
+            assertTrue(q.isEmpty());
+        }
+    }
+
+    /**
+     * Descending iterator iterates through all elements
+     */
+    public void testDescendingIterator() {
+        ArrayDeque q = populatedDeque(SIZE);
+        int i = 0;
+        Iterator it = q.descendingIterator();
+        while (it.hasNext()) {
+            assertTrue(q.contains(it.next()));
+            ++i;
+        }
+        assertEquals(i, SIZE);
         assertFalse(it.hasNext());
+        try {
+            it.next();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
+    }
+
+    /**
+     * Descending iterator ordering is reverse FIFO
+     */
+    public void testDescendingIteratorOrdering() {
+        final ArrayDeque q = new ArrayDeque();
+        for (int iters = 0; iters < 100; ++iters) {
+            q.add(new Integer(3));
+            q.add(new Integer(2));
+            q.add(new Integer(1));
+            int k = 0;
+            for (Iterator it = q.descendingIterator(); it.hasNext();) {
+                assertEquals(++k, it.next());
+            }
+
+            assertEquals(3, k);
+            q.remove();
+            q.remove();
+            q.remove();
+        }
+    }
+
+    /**
+     * descendingIterator.remove() removes current element
+     */
+    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;
+            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));
+            for (int j = 1; j <= split; ++j)
+                q.remove(new Integer(j));
+            it = q.descendingIterator();
+            for (int j = split+1; j <= max; ++j) {
+                assertEquals(it.next(), new Integer(j));
+                it.remove();
+            }
+            assertFalse(it.hasNext());
+            assertTrue(q.isEmpty());
+        }
     }
 
 
     /**
-     * toString contains toStrings of elements
+     * toString() contains toStrings of elements
      */
     public void testToString() {
         ArrayDeque q = populatedDeque(SIZE);
@@ -550,24 +807,24 @@ public class ArrayDequeTest extends JSR1
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(s.indexOf(String.valueOf(i)) >= 0);
         }
-    }        
-
-    /**
-     * peekFirst returns element inserted with addFirst
-     */
-    public void testAddFirst() {
-        ArrayDeque q = populatedDeque(3);
-	q.addFirst(four);
-	assertEquals(four,q.peekFirst());
-    }	
+    }
 
     /**
-     * peekLast returns element inserted with addLast
+     * A deserialized serialized deque has same elements in same order
      */
-    public void testAddLast() {
-        ArrayDeque q = populatedDeque(3);
-	q.addLast(four);
-	assertEquals(four,q.peekLast());
-    }	
+    public void testSerialization() throws Exception {
+        ArrayDeque q = populatedDeque(SIZE);
+        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+        out.writeObject(q);
+        out.close();
+
+        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+        ArrayDeque r = (ArrayDeque)in.readObject();
+        assertEquals(q.size(), r.size());
+        while (!q.isEmpty())
+            assertEquals(q.remove(), r.remove());
+    }
 
 }