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.36 by jsr166, Sat May 23 00:53:08 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 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 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 660 | Line 711 | public class ArrayDequeTest extends JSR1
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 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