--- jsr166/src/test/tck/ArrayDequeTest.java	2016/10/16 22:13:15	1.42
+++ jsr166/src/test/tck/ArrayDequeTest.java	2016/10/21 03:24:00	1.49
@@ -1,17 +1,20 @@
 /*
- * Written by Doug Lea with assistance from members of JCP JSR-166
- * Expert Group and released to the public domain, as explained at
+ * Written by Doug Lea and Martin Buchholz 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/
  */
 
 import java.util.ArrayDeque;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Deque;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Queue;
 import java.util.Random;
+import java.util.Spliterator;
 import java.util.concurrent.ThreadLocalRandom;
 
 import junit.framework.Test;
@@ -25,7 +28,7 @@ public class ArrayDequeTest extends JSR1
     public static Test suite() {
         class Implementation implements CollectionImplementation {
             public Class<?> klazz() { return ArrayDeque.class; }
-            public Collection emptyCollection() { return new ArrayDeque(); }
+            public Collection emptyCollection() { return populatedDeque(0); }
             public Object makeElement(int i) { return i; }
             public boolean isConcurrent() { return false; }
             public boolean permitsNulls() { return false; }
@@ -38,17 +41,17 @@ public class ArrayDequeTest extends JSR1
      * Returns a new deque of given size containing consecutive
      * Integers 0 ... n - 1.
      */
-    private ArrayDeque<Integer> populatedDeque(int n) {
+    private static ArrayDeque<Integer> populatedDeque(int n) {
         // Randomize various aspects of memory layout, including
         // filled-to-capacity and wraparound.
         final ArrayDeque<Integer> q;
         ThreadLocalRandom rnd = ThreadLocalRandom.current();
         switch (rnd.nextInt(6)) {
-        case 0: q = new ArrayDeque<Integer>(); break;
-        case 1: q = new ArrayDeque<Integer>(0); break;
-        case 2: q = new ArrayDeque<Integer>(1); break;
-        case 3: q = new ArrayDeque<Integer>(n - 1); break;
-        case 4: q = new ArrayDeque<Integer>(n); break;
+        case 0: q = new ArrayDeque<Integer>();      break;
+        case 1: q = new ArrayDeque<Integer>(0);     break;
+        case 2: q = new ArrayDeque<Integer>(1);     break;
+        case 3: q = new ArrayDeque<Integer>(Math.max(0, n - 1)); break;
+        case 4: q = new ArrayDeque<Integer>(n);     break;
         case 5: q = new ArrayDeque<Integer>(n + 1); break;
         default: throw new AssertionError();
         }
@@ -59,7 +62,7 @@ public class ArrayDequeTest extends JSR1
             break;
         case 1:
             q.addLast(42);
-            assertEquals((Integer) 42, q.removeLast());
+            assertEquals((Integer) 42, q.removeFirst());
             break;
         case 2: /* do nothing */ break;
         default: throw new AssertionError();
@@ -71,10 +74,12 @@ public class ArrayDequeTest extends JSR1
         else
             for (int i = n; --i >= 0; )
                 q.addFirst((Integer) i);
-        assertFalse(q.isEmpty());
         assertEquals(n, q.size());
-        assertEquals((Integer) 0, q.peekFirst());
-        assertEquals((Integer) (n - 1), q.peekLast());
+        if (n > 0) {
+            assertFalse(q.isEmpty());
+            assertEquals((Integer) 0, q.peekFirst());
+            assertEquals((Integer) (n - 1), q.peekLast());
+        }
         return q;
     }
 
@@ -950,6 +955,24 @@ public class ArrayDequeTest extends JSR1
     }
 
     /**
+     * A cloned deque has same elements in same order
+     */
+    public void testClone() throws Exception {
+        ArrayDeque<Integer> x = populatedDeque(SIZE);
+        ArrayDeque<Integer> y = x.clone();
+
+        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());
+    }
+
+    /**
      * remove(null), contains(null) always return false
      */
     public void testNeverContainsNull() {
@@ -966,4 +989,68 @@ public class ArrayDequeTest extends JSR1
         }
     }
 
+    /**
+     * Spliterator characteristics are as advertised
+     */
+    public void testSpliterator_characteristics() {
+        ArrayDeque q = new ArrayDeque();
+        Spliterator s = q.spliterator();
+        int characteristics = s.characteristics();
+        int required = Spliterator.NONNULL
+            | Spliterator.ORDERED
+            | Spliterator.SIZED
+            | Spliterator.SUBSIZED;
+        assertEquals(required, characteristics & required);
+        assertTrue(s.hasCharacteristics(required));
+        assertEquals(0, characteristics
+                     & (Spliterator.CONCURRENT
+                        | Spliterator.DISTINCT
+                        | Spliterator.IMMUTABLE
+                        | Spliterator.SORTED));
+    }
+
+    /**
+     * Spliterator.getComparator always throws IllegalStateException
+     */
+    public void testSpliterator_getComparator() {
+        assertThrows(IllegalStateException.class,
+                     () -> new ArrayDeque().spliterator().getComparator());
+    }
+
+    /**
+     * Handle capacities near Integer.MAX_VALUE.
+     * ant -Dvmoptions='-Xms22g -Xmx22g' -Djsr166.testImplementationDetails=true -Djsr166.expensiveTests=true -Djsr166.tckTestClass=ArrayDequeTest -Djsr166.methodFilter=testHuge tck
+     */
+    public void testHuge() {
+        if (! (testImplementationDetails
+               && expensiveTests
+               && Runtime.getRuntime().maxMemory() > 21_000_000_000L))
+            return;
+
+        ArrayDeque q;
+        final int maxSize = Integer.MAX_VALUE - 8;
+
+        assertThrows(OutOfMemoryError.class,
+                     () -> new ArrayDeque<>(Integer.MAX_VALUE));
+
+        {
+            q = new ArrayDeque<>(maxSize);
+            q = null;
+        }
+
+        {
+            q = new ArrayDeque();
+            assertTrue(q.addAll(Collections.nCopies(maxSize - 2, (Integer) 42)));
+            assertEquals((Integer) 42, q.peekFirst());
+            assertEquals((Integer) 42, q.peekLast());
+            assertEquals(maxSize - 2, q.size());
+            q.addFirst((Integer) 0);
+            q.addLast((Integer) 1);
+            assertEquals((Integer) 0, q.peekFirst());
+            assertEquals((Integer) 1, q.peekLast());
+            assertEquals(maxSize, q.size());
+            q = null;
+        }
+    }
+
 }