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.35 by jsr166, Fri May 15 18:21:19 2015 UTC vs.
Revision 1.42 by jsr166, Sun Oct 16 22:13:15 2016 UTC

# Line 12 | Line 12 | import java.util.Iterator;
12   import java.util.NoSuchElementException;
13   import java.util.Queue;
14   import java.util.Random;
15 + import java.util.concurrent.ThreadLocalRandom;
16  
17   import junit.framework.Test;
18   import junit.framework.TestSuite;
# Line 22 | Line 23 | public class ArrayDequeTest extends JSR1
23      }
24  
25      public static Test suite() {
26 <        return new TestSuite(ArrayDequeTest.class);
26 >        class Implementation implements CollectionImplementation {
27 >            public Class<?> klazz() { return ArrayDeque.class; }
28 >            public Collection emptyCollection() { return new ArrayDeque(); }
29 >            public Object makeElement(int i) { return i; }
30 >            public boolean isConcurrent() { return false; }
31 >            public boolean permitsNulls() { return false; }
32 >        }
33 >        return newTestSuite(ArrayDequeTest.class,
34 >                            CollectionTest.testSuite(new Implementation()));
35      }
36  
37      /**
38       * Returns a new deque of given size containing consecutive
39 <     * Integers 0 ... n.
39 >     * Integers 0 ... n - 1.
40       */
41      private ArrayDeque<Integer> populatedDeque(int n) {
42 <        ArrayDeque<Integer> q = new ArrayDeque<Integer>();
42 >        // Randomize various aspects of memory layout, including
43 >        // filled-to-capacity and wraparound.
44 >        final ArrayDeque<Integer> q;
45 >        ThreadLocalRandom rnd = ThreadLocalRandom.current();
46 >        switch (rnd.nextInt(6)) {
47 >        case 0: q = new ArrayDeque<Integer>(); break;
48 >        case 1: q = new ArrayDeque<Integer>(0); break;
49 >        case 2: q = new ArrayDeque<Integer>(1); break;
50 >        case 3: q = new ArrayDeque<Integer>(n - 1); break;
51 >        case 4: q = new ArrayDeque<Integer>(n); break;
52 >        case 5: q = new ArrayDeque<Integer>(n + 1); break;
53 >        default: throw new AssertionError();
54 >        }
55 >        switch (rnd.nextInt(3)) {
56 >        case 0:
57 >            q.addFirst(42);
58 >            assertEquals((Integer) 42, q.removeLast());
59 >            break;
60 >        case 1:
61 >            q.addLast(42);
62 >            assertEquals((Integer) 42, q.removeLast());
63 >            break;
64 >        case 2: /* do nothing */ break;
65 >        default: throw new AssertionError();
66 >        }
67          assertTrue(q.isEmpty());
68 <        for (int i = 0; i < n; ++i)
69 <            assertTrue(q.offerLast(new Integer(i)));
68 >        if (rnd.nextBoolean())
69 >            for (int i = 0; i < n; i++)
70 >                assertTrue(q.offerLast((Integer) i));
71 >        else
72 >            for (int i = n; --i >= 0; )
73 >                q.addFirst((Integer) i);
74          assertFalse(q.isEmpty());
75          assertEquals(n, q.size());
76 +        assertEquals((Integer) 0, q.peekFirst());
77 +        assertEquals((Integer) (n - 1), q.peekLast());
78          return q;
79      }
80  
# Line 71 | Line 110 | public class ArrayDequeTest extends JSR1
110       */
111      public void testConstructor5() {
112          Integer[] ints = new Integer[SIZE];
113 <        for (int i = 0; i < SIZE-1; ++i)
113 >        for (int i = 0; i < SIZE - 1; ++i)
114              ints[i] = new Integer(i);
115          try {
116              new ArrayDeque(Arrays.asList(ints));
# Line 111 | Line 150 | public class ArrayDequeTest extends JSR1
150      public void testSize() {
151          ArrayDeque q = populatedDeque(SIZE);
152          for (int i = 0; i < SIZE; ++i) {
153 <            assertEquals(SIZE-i, q.size());
153 >            assertEquals(SIZE - i, q.size());
154              q.removeFirst();
155          }
156          for (int i = 0; i < SIZE; ++i) {
# Line 316 | Line 355 | public class ArrayDequeTest extends JSR1
355      public void testAddAll3() {
356          ArrayDeque q = new ArrayDeque();
357          Integer[] ints = new Integer[SIZE];
358 <        for (int i = 0; i < SIZE-1; ++i)
358 >        for (int i = 0; i < SIZE - 1; ++i)
359              ints[i] = new Integer(i);
360          try {
361              q.addAll(Arrays.asList(ints));
# Line 355 | Line 394 | public class ArrayDequeTest extends JSR1
394       */
395      public void testPollLast() {
396          ArrayDeque q = populatedDeque(SIZE);
397 <        for (int i = SIZE-1; i >= 0; --i) {
397 >        for (int i = SIZE - 1; i >= 0; --i) {
398              assertEquals(i, q.pollLast());
399          }
400          assertNull(q.pollLast());
# Line 395 | Line 434 | public class ArrayDequeTest extends JSR1
434              assertTrue(q.contains(i));
435              assertTrue(q.remove(i));
436              assertFalse(q.contains(i));
437 <            assertTrue(q.contains(i-1));
437 >            assertTrue(q.contains(i - 1));
438          }
439          for (int i = 0; i < SIZE; i += 2) {
440              assertTrue(q.contains(i));
441              assertTrue(q.remove(i));
442              assertFalse(q.contains(i));
443 <            assertFalse(q.remove(i+1));
444 <            assertFalse(q.contains(i+1));
443 >            assertFalse(q.remove(i + 1));
444 >            assertFalse(q.contains(i + 1));
445          }
446          assertTrue(q.isEmpty());
447      }
# Line 440 | Line 479 | public class ArrayDequeTest extends JSR1
479       */
480      public void testPeekLast() {
481          ArrayDeque q = populatedDeque(SIZE);
482 <        for (int i = SIZE-1; i >= 0; --i) {
482 >        for (int i = SIZE - 1; i >= 0; --i) {
483              assertEquals(i, q.peekLast());
484              assertEquals(i, q.pollLast());
485              assertTrue(q.peekLast() == null ||
# Line 484 | Line 523 | public class ArrayDequeTest extends JSR1
523       */
524      public void testLastElement() {
525          ArrayDeque q = populatedDeque(SIZE);
526 <        for (int i = SIZE-1; i >= 0; --i) {
526 >        for (int i = SIZE - 1; i >= 0; --i) {
527              assertEquals(i, q.getLast());
528              assertEquals(i, q.pollLast());
529          }
# Line 530 | Line 569 | public class ArrayDequeTest extends JSR1
569       */
570      public void testRemoveFirstOccurrence() {
571          ArrayDeque q = populatedDeque(SIZE);
572 +        assertFalse(q.removeFirstOccurrence(null));
573          for (int i = 1; i < SIZE; i += 2) {
574              assertTrue(q.removeFirstOccurrence(new Integer(i)));
575          }
576          for (int i = 0; i < SIZE; i += 2) {
577              assertTrue(q.removeFirstOccurrence(new Integer(i)));
578 <            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
578 >            assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
579          }
580          assertTrue(q.isEmpty());
581 +        assertFalse(q.removeFirstOccurrence(null));
582 +        assertFalse(q.removeFirstOccurrence(42));
583 +        q = new ArrayDeque();
584 +        assertFalse(q.removeFirstOccurrence(null));
585 +        assertFalse(q.removeFirstOccurrence(42));
586      }
587  
588      /**
# Line 545 | Line 590 | public class ArrayDequeTest extends JSR1
590       */
591      public void testRemoveLastOccurrence() {
592          ArrayDeque q = populatedDeque(SIZE);
593 +        assertFalse(q.removeLastOccurrence(null));
594          for (int i = 1; i < SIZE; i += 2) {
595              assertTrue(q.removeLastOccurrence(new Integer(i)));
596          }
597          for (int i = 0; i < SIZE; i += 2) {
598              assertTrue(q.removeLastOccurrence(new Integer(i)));
599 <            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
599 >            assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
600          }
601          assertTrue(q.isEmpty());
602 +        assertFalse(q.removeLastOccurrence(null));
603 +        assertFalse(q.removeLastOccurrence(42));
604 +        q = new ArrayDeque();
605 +        assertFalse(q.removeLastOccurrence(null));
606 +        assertFalse(q.removeLastOccurrence(42));
607      }
608  
609      /**
# Line 605 | Line 656 | public class ArrayDequeTest extends JSR1
656              boolean changed = q.retainAll(p);
657              assertEquals(changed, (i > 0));
658              assertTrue(q.containsAll(p));
659 <            assertEquals(SIZE-i, q.size());
659 >            assertEquals(SIZE - i, q.size());
660              p.removeFirst();
661          }
662      }
# Line 618 | Line 669 | public class ArrayDequeTest extends JSR1
669              ArrayDeque q = populatedDeque(SIZE);
670              ArrayDeque p = populatedDeque(i);
671              assertTrue(q.removeAll(p));
672 <            assertEquals(SIZE-i, q.size());
672 >            assertEquals(SIZE - i, q.size());
673              for (int j = 0; j < i; ++j) {
674                  assertFalse(q.contains(p.removeFirst()));
675              }
# Line 650 | Line 701 | public class ArrayDequeTest extends JSR1
701          for (int i = 0; i < SIZE; i++) {
702              checkToArray(q);
703              assertEquals(i, q.poll());
704 <            q.addLast(SIZE+i);
704 >            q.addLast(SIZE + i);
705          }
706          for (int i = 0; i < SIZE; i++) {
707              checkToArray(q);
708 <            assertEquals(SIZE+i, q.poll());
708 >            assertEquals(SIZE + i, q.poll());
709          }
710      }
711  
712      void checkToArray2(ArrayDeque q) {
713          int size = q.size();
714 <        Integer[] a1 = size == 0 ? null : new Integer[size-1];
714 >        Integer[] a1 = (size == 0) ? null : new Integer[size - 1];
715          Integer[] a2 = new Integer[size];
716 <        Integer[] a3 = new Integer[size+2];
716 >        Integer[] a3 = new Integer[size + 2];
717          if (size > 0) Arrays.fill(a1, 42);
718          Arrays.fill(a2, 42);
719          Arrays.fill(a3, 42);
720 <        Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
720 >        Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);
721          Integer[] b2 = (Integer[]) q.toArray(a2);
722          Integer[] b3 = (Integer[]) q.toArray(a3);
723          assertSame(a2, b2);
# Line 680 | Line 731 | public class ArrayDequeTest extends JSR1
731              assertSame(b3[i], x);
732          }
733          assertNull(a3[size]);
734 <        assertEquals(42, (int) a3[size+1]);
734 >        assertEquals(42, (int) a3[size + 1]);
735          if (size > 0) {
736              assertNotSame(a1, b1);
737              assertEquals(size, b1.length);
# Line 703 | Line 754 | public class ArrayDequeTest extends JSR1
754          for (int i = 0; i < SIZE; i++) {
755              checkToArray2(q);
756              assertEquals(i, q.poll());
757 <            q.addLast(SIZE+i);
757 >            q.addLast(SIZE + i);
758          }
759          for (int i = 0; i < SIZE; i++) {
760              checkToArray2(q);
761 <            assertEquals(SIZE+i, q.poll());
761 >            assertEquals(SIZE + i, q.poll());
762          }
763      }
764  
# Line 781 | Line 832 | public class ArrayDequeTest extends JSR1
832          final Random rng = new Random();
833          for (int iters = 0; iters < 100; ++iters) {
834              int max = rng.nextInt(5) + 2;
835 <            int split = rng.nextInt(max-1) + 1;
835 >            int split = rng.nextInt(max - 1) + 1;
836              for (int j = 1; j <= max; ++j)
837                  q.add(new Integer(j));
838              Iterator it = q.iterator();
839              for (int j = 1; j <= split; ++j)
840                  assertEquals(it.next(), new Integer(j));
841              it.remove();
842 <            assertEquals(it.next(), new Integer(split+1));
842 >            assertEquals(it.next(), new Integer(split + 1));
843              for (int j = 1; j <= split; ++j)
844                  q.remove(new Integer(j));
845              it = q.iterator();
846 <            for (int j = split+1; j <= max; ++j) {
846 >            for (int j = split + 1; j <= max; ++j) {
847                  assertEquals(it.next(), new Integer(j));
848                  it.remove();
849              }
# Line 849 | Line 900 | public class ArrayDequeTest extends JSR1
900          final Random rng = new Random();
901          for (int iters = 0; iters < 100; ++iters) {
902              int max = rng.nextInt(5) + 2;
903 <            int split = rng.nextInt(max-1) + 1;
903 >            int split = rng.nextInt(max - 1) + 1;
904              for (int j = max; j >= 1; --j)
905                  q.add(new Integer(j));
906              Iterator it = q.descendingIterator();
907              for (int j = 1; j <= split; ++j)
908                  assertEquals(it.next(), new Integer(j));
909              it.remove();
910 <            assertEquals(it.next(), new Integer(split+1));
910 >            assertEquals(it.next(), new Integer(split + 1));
911              for (int j = 1; j <= split; ++j)
912                  q.remove(new Integer(j));
913              it = q.descendingIterator();
914 <            for (int j = split+1; j <= max; ++j) {
914 >            for (int j = split + 1; j <= max; ++j) {
915                  assertEquals(it.next(), new Integer(j));
916                  it.remove();
917              }

Diff Legend

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