ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ArrayDequeTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ArrayDequeTest.java (file contents):
Revision 1.37 by jsr166, Sun May 24 01:23:17 2015 UTC vs.
Revision 1.43 by jsr166, Mon Oct 17 00:59:53 2016 UTC

# Line 7 | Line 7
7   import java.util.ArrayDeque;
8   import java.util.Arrays;
9   import java.util.Collection;
10 + import java.util.Collections;
11   import java.util.Deque;
12   import java.util.Iterator;
13   import java.util.NoSuchElementException;
14   import java.util.Queue;
15   import java.util.Random;
16 + import java.util.concurrent.ThreadLocalRandom;
17  
18   import junit.framework.Test;
19   import junit.framework.TestSuite;
# Line 22 | Line 24 | public class ArrayDequeTest extends JSR1
24      }
25  
26      public static Test suite() {
27 <        return new TestSuite(ArrayDequeTest.class);
27 >        class Implementation implements CollectionImplementation {
28 >            public Class<?> klazz() { return ArrayDeque.class; }
29 >            public Collection emptyCollection() { return new ArrayDeque(); }
30 >            public Object makeElement(int i) { return i; }
31 >            public boolean isConcurrent() { return false; }
32 >            public boolean permitsNulls() { return false; }
33 >        }
34 >        return newTestSuite(ArrayDequeTest.class,
35 >                            CollectionTest.testSuite(new Implementation()));
36      }
37  
38      /**
39       * Returns a new deque of given size containing consecutive
40 <     * Integers 0 ... n.
40 >     * Integers 0 ... n - 1.
41       */
42      private ArrayDeque<Integer> populatedDeque(int n) {
43 <        ArrayDeque<Integer> q = new ArrayDeque<Integer>();
43 >        // Randomize various aspects of memory layout, including
44 >        // filled-to-capacity and wraparound.
45 >        final ArrayDeque<Integer> q;
46 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
47 >        switch (rnd.nextInt(6)) {
48 >        case 0: q = new ArrayDeque<Integer>();      break;
49 >        case 1: q = new ArrayDeque<Integer>(0);     break;
50 >        case 2: q = new ArrayDeque<Integer>(1);     break;
51 >        case 3: q = new ArrayDeque<Integer>(Math.max(0, n - 1)); break;
52 >        case 4: q = new ArrayDeque<Integer>(n);     break;
53 >        case 5: q = new ArrayDeque<Integer>(n + 1); break;
54 >        default: throw new AssertionError();
55 >        }
56 >        switch (rnd.nextInt(3)) {
57 >        case 0:
58 >            q.addFirst(42);
59 >            assertEquals((Integer) 42, q.removeLast());
60 >            break;
61 >        case 1:
62 >            q.addLast(42);
63 >            assertEquals((Integer) 42, q.removeFirst());
64 >            break;
65 >        case 2: /* do nothing */ break;
66 >        default: throw new AssertionError();
67 >        }
68          assertTrue(q.isEmpty());
69 <        for (int i = 0; i < n; ++i)
70 <            assertTrue(q.offerLast(new Integer(i)));
71 <        assertFalse(q.isEmpty());
69 >        if (rnd.nextBoolean())
70 >            for (int i = 0; i < n; i++)
71 >                assertTrue(q.offerLast((Integer) i));
72 >        else
73 >            for (int i = n; --i >= 0; )
74 >                q.addFirst((Integer) i);
75          assertEquals(n, q.size());
76 +        if (n > 0) {
77 +            assertFalse(q.isEmpty());
78 +            assertEquals((Integer) 0, q.peekFirst());
79 +            assertEquals((Integer) (n - 1), q.peekLast());
80 +        }
81          return q;
82      }
83  
# Line 395 | Line 437 | public class ArrayDequeTest extends JSR1
437              assertTrue(q.contains(i));
438              assertTrue(q.remove(i));
439              assertFalse(q.contains(i));
440 <            assertTrue(q.contains(i-1));
440 >            assertTrue(q.contains(i - 1));
441          }
442          for (int i = 0; i < SIZE; i += 2) {
443              assertTrue(q.contains(i));
444              assertTrue(q.remove(i));
445              assertFalse(q.contains(i));
446 <            assertFalse(q.remove(i+1));
447 <            assertFalse(q.contains(i+1));
446 >            assertFalse(q.remove(i + 1));
447 >            assertFalse(q.contains(i + 1));
448          }
449          assertTrue(q.isEmpty());
450      }
# Line 530 | Line 572 | public class ArrayDequeTest extends JSR1
572       */
573      public void testRemoveFirstOccurrence() {
574          ArrayDeque q = populatedDeque(SIZE);
575 +        assertFalse(q.removeFirstOccurrence(null));
576          for (int i = 1; i < SIZE; i += 2) {
577              assertTrue(q.removeFirstOccurrence(new Integer(i)));
578          }
579          for (int i = 0; i < SIZE; i += 2) {
580              assertTrue(q.removeFirstOccurrence(new Integer(i)));
581 <            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
581 >            assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
582          }
583          assertTrue(q.isEmpty());
584 +        assertFalse(q.removeFirstOccurrence(null));
585 +        assertFalse(q.removeFirstOccurrence(42));
586 +        q = new ArrayDeque();
587 +        assertFalse(q.removeFirstOccurrence(null));
588 +        assertFalse(q.removeFirstOccurrence(42));
589      }
590  
591      /**
# Line 545 | Line 593 | public class ArrayDequeTest extends JSR1
593       */
594      public void testRemoveLastOccurrence() {
595          ArrayDeque q = populatedDeque(SIZE);
596 +        assertFalse(q.removeLastOccurrence(null));
597          for (int i = 1; i < SIZE; i += 2) {
598              assertTrue(q.removeLastOccurrence(new Integer(i)));
599          }
600          for (int i = 0; i < SIZE; i += 2) {
601              assertTrue(q.removeLastOccurrence(new Integer(i)));
602 <            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
602 >            assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
603          }
604          assertTrue(q.isEmpty());
605 +        assertFalse(q.removeLastOccurrence(null));
606 +        assertFalse(q.removeLastOccurrence(42));
607 +        q = new ArrayDeque();
608 +        assertFalse(q.removeLastOccurrence(null));
609 +        assertFalse(q.removeLastOccurrence(42));
610      }
611  
612      /**
# Line 781 | Line 835 | public class ArrayDequeTest extends JSR1
835          final Random rng = new Random();
836          for (int iters = 0; iters < 100; ++iters) {
837              int max = rng.nextInt(5) + 2;
838 <            int split = rng.nextInt(max-1) + 1;
838 >            int split = rng.nextInt(max - 1) + 1;
839              for (int j = 1; j <= max; ++j)
840                  q.add(new Integer(j));
841              Iterator it = q.iterator();
842              for (int j = 1; j <= split; ++j)
843                  assertEquals(it.next(), new Integer(j));
844              it.remove();
845 <            assertEquals(it.next(), new Integer(split+1));
845 >            assertEquals(it.next(), new Integer(split + 1));
846              for (int j = 1; j <= split; ++j)
847                  q.remove(new Integer(j));
848              it = q.iterator();
849 <            for (int j = split+1; j <= max; ++j) {
849 >            for (int j = split + 1; j <= max; ++j) {
850                  assertEquals(it.next(), new Integer(j));
851                  it.remove();
852              }
# Line 849 | Line 903 | public class ArrayDequeTest extends JSR1
903          final Random rng = new Random();
904          for (int iters = 0; iters < 100; ++iters) {
905              int max = rng.nextInt(5) + 2;
906 <            int split = rng.nextInt(max-1) + 1;
906 >            int split = rng.nextInt(max - 1) + 1;
907              for (int j = max; j >= 1; --j)
908                  q.add(new Integer(j));
909              Iterator it = q.descendingIterator();
910              for (int j = 1; j <= split; ++j)
911                  assertEquals(it.next(), new Integer(j));
912              it.remove();
913 <            assertEquals(it.next(), new Integer(split+1));
913 >            assertEquals(it.next(), new Integer(split + 1));
914              for (int j = 1; j <= split; ++j)
915                  q.remove(new Integer(j));
916              it = q.descendingIterator();
917 <            for (int j = split+1; j <= max; ++j) {
917 >            for (int j = split + 1; j <= max; ++j) {
918                  assertEquals(it.next(), new Integer(j));
919                  it.remove();
920              }
# Line 899 | Line 953 | public class ArrayDequeTest extends JSR1
953      }
954  
955      /**
956 +     * A cloned deque has same elements in same order
957 +     */
958 +    public void testClone() throws Exception {
959 +        ArrayDeque<Integer> x = populatedDeque(SIZE);
960 +        ArrayDeque<Integer> y = x.clone();
961 +
962 +        assertNotSame(y, x);
963 +        assertEquals(x.size(), y.size());
964 +        assertEquals(x.toString(), y.toString());
965 +        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
966 +        while (!x.isEmpty()) {
967 +            assertFalse(y.isEmpty());
968 +            assertEquals(x.remove(), y.remove());
969 +        }
970 +        assertTrue(y.isEmpty());
971 +    }
972 +
973 +    /**
974       * remove(null), contains(null) always return false
975       */
976      public void testNeverContainsNull() {
# Line 915 | Line 987 | public class ArrayDequeTest extends JSR1
987          }
988      }
989  
990 +    /**
991 +     * Handle capacities near Integer.MAX_VALUE.
992 +     * ant -Dvmoptions=-Xmx24g -Djsr166.expensiveTests=true -Djsr166.tckTestClass=ArrayDequeTest -Djsr166.methodFilter=testHuge tck
993 +     */
994 +    public void testHuge() {
995 +        if (! (testImplementationDetails
996 +               && expensiveTests
997 +               && Runtime.getRuntime().freeMemory() > 21_000_000_000L))
998 +            return;
999 +        int maxSize = Integer.MAX_VALUE - 8;
1000 +        ArrayDeque<Integer> q;
1001 +
1002 +        q = new ArrayDeque<>(maxSize);
1003 +
1004 +        assertThrows(OutOfMemoryError.class,
1005 +                     () -> new ArrayDeque<>(Integer.MAX_VALUE));
1006 +
1007 +        q = populatedDeque(0);
1008 +        q.addAll(Collections.nCopies(maxSize - 2, (Integer) 42));
1009 +        assertEquals((Integer) 42, q.peekFirst());
1010 +        assertEquals((Integer) 42, q.peekLast());
1011 +        assertEquals(maxSize - 2, q.size());
1012 +        q.addFirst((Integer) 0);
1013 +        q.addLast((Integer) 1);
1014 +        assertEquals((Integer) 0, q.peekFirst());
1015 +        assertEquals((Integer) 1, q.peekLast());
1016 +        assertEquals(maxSize, q.size());
1017 +    }
1018 +
1019   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines