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.24 by jsr166, Tue May 31 16:16:23 2011 UTC vs.
Revision 1.41 by jsr166, Sun Oct 16 20:44:18 2016 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 – import junit.framework.*;
8 – import java.util.Arrays;
7   import java.util.ArrayDeque;
8 + import java.util.Arrays;
9   import java.util.Collection;
10   import java.util.Deque;
11   import java.util.Iterator;
# Line 14 | Line 13 | import java.util.NoSuchElementException;
13   import java.util.Queue;
14   import java.util.Random;
15  
16 + import junit.framework.Test;
17 + import junit.framework.TestSuite;
18 +
19   public class ArrayDequeTest extends JSR166TestCase {
20      public static void main(String[] args) {
21 <        junit.textui.TestRunner.run(suite());
21 >        main(suite(), args);
22      }
23  
24      public static Test suite() {
25 <        return new TestSuite(ArrayDequeTest.class);
25 >        class Implementation implements CollectionImplementation {
26 >            public Class<?> klazz() { return ArrayDeque.class; }
27 >            public Collection emptyCollection() { return new ArrayDeque(); }
28 >            public Object makeElement(int i) { return i; }
29 >            public boolean isConcurrent() { return false; }
30 >            public boolean permitsNulls() { return false; }
31 >        }
32 >        return newTestSuite(ArrayDequeTest.class,
33 >                            CollectionTest.testSuite(new Implementation()));
34      }
35  
36      /**
37 <     * Create a deque of given size containing consecutive
38 <     * Integers 0 ... n.
37 >     * Returns a new deque of given size containing consecutive
38 >     * Integers 0 ... n - 1.
39       */
40      private ArrayDeque<Integer> populatedDeque(int n) {
41          ArrayDeque<Integer> q = new ArrayDeque<Integer>();
# Line 34 | Line 44 | public class ArrayDequeTest extends JSR1
44              assertTrue(q.offerLast(new Integer(i)));
45          assertFalse(q.isEmpty());
46          assertEquals(n, q.size());
47 +        assertEquals((Integer) 0, q.peekFirst());
48 +        assertEquals((Integer) (n - 1), q.peekLast());
49          return q;
50      }
51  
# Line 49 | Line 61 | public class ArrayDequeTest extends JSR1
61       */
62      public void testConstructor3() {
63          try {
64 <            ArrayDeque q = new ArrayDeque((Collection)null);
64 >            new ArrayDeque((Collection)null);
65              shouldThrow();
66          } catch (NullPointerException success) {}
67      }
# Line 59 | Line 71 | public class ArrayDequeTest extends JSR1
71       */
72      public void testConstructor4() {
73          try {
74 <            Integer[] ints = new Integer[SIZE];
63 <            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
74 >            new ArrayDeque(Arrays.asList(new Integer[SIZE]));
75              shouldThrow();
76          } catch (NullPointerException success) {}
77      }
# Line 69 | Line 80 | public class ArrayDequeTest extends JSR1
80       * Initializing from Collection with some null elements throws NPE
81       */
82      public void testConstructor5() {
83 +        Integer[] ints = new Integer[SIZE];
84 +        for (int i = 0; i < SIZE - 1; ++i)
85 +            ints[i] = new Integer(i);
86          try {
87 <            Integer[] ints = new Integer[SIZE];
74 <            for (int i = 0; i < SIZE-1; ++i)
75 <                ints[i] = new Integer(i);
76 <            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
87 >            new ArrayDeque(Arrays.asList(ints));
88              shouldThrow();
89          } catch (NullPointerException success) {}
90      }
# Line 110 | Line 121 | public class ArrayDequeTest extends JSR1
121      public void testSize() {
122          ArrayDeque q = populatedDeque(SIZE);
123          for (int i = 0; i < SIZE; ++i) {
124 <            assertEquals(SIZE-i, q.size());
124 >            assertEquals(SIZE - i, q.size());
125              q.removeFirst();
126          }
127          for (int i = 0; i < SIZE; ++i) {
# Line 123 | Line 134 | public class ArrayDequeTest extends JSR1
134       * push(null) throws NPE
135       */
136      public void testPushNull() {
137 +        ArrayDeque q = new ArrayDeque(1);
138          try {
127 –            ArrayDeque q = new ArrayDeque(1);
139              q.push(null);
140              shouldThrow();
141          } catch (NullPointerException success) {}
# Line 158 | Line 169 | public class ArrayDequeTest extends JSR1
169       * offer(null) throws NPE
170       */
171      public void testOfferNull() {
172 +        ArrayDeque q = new ArrayDeque();
173          try {
162 –            ArrayDeque q = new ArrayDeque();
174              q.offer(null);
175              shouldThrow();
176          } catch (NullPointerException success) {}
# Line 169 | Line 180 | public class ArrayDequeTest extends JSR1
180       * offerFirst(null) throws NPE
181       */
182      public void testOfferFirstNull() {
183 +        ArrayDeque q = new ArrayDeque();
184          try {
173 –            ArrayDeque q = new ArrayDeque();
185              q.offerFirst(null);
186              shouldThrow();
187          } catch (NullPointerException success) {}
# Line 180 | Line 191 | public class ArrayDequeTest extends JSR1
191       * offerLast(null) throws NPE
192       */
193      public void testOfferLastNull() {
194 +        ArrayDeque q = new ArrayDeque();
195          try {
184 –            ArrayDeque q = new ArrayDeque();
196              q.offerLast(null);
197              shouldThrow();
198          } catch (NullPointerException success) {}
# Line 224 | Line 235 | public class ArrayDequeTest extends JSR1
235       * add(null) throws NPE
236       */
237      public void testAddNull() {
238 +        ArrayDeque q = new ArrayDeque();
239          try {
228 –            ArrayDeque q = new ArrayDeque();
240              q.add(null);
241              shouldThrow();
242          } catch (NullPointerException success) {}
# Line 235 | Line 246 | public class ArrayDequeTest extends JSR1
246       * addFirst(null) throws NPE
247       */
248      public void testAddFirstNull() {
249 +        ArrayDeque q = new ArrayDeque();
250          try {
239 –            ArrayDeque q = new ArrayDeque();
251              q.addFirst(null);
252              shouldThrow();
253          } catch (NullPointerException success) {}
# Line 246 | Line 257 | public class ArrayDequeTest extends JSR1
257       * addLast(null) throws NPE
258       */
259      public void testAddLastNull() {
260 +        ArrayDeque q = new ArrayDeque();
261          try {
250 –            ArrayDeque q = new ArrayDeque();
262              q.addLast(null);
263              shouldThrow();
264          } catch (NullPointerException success) {}
# Line 290 | Line 301 | public class ArrayDequeTest extends JSR1
301       * addAll(null) throws NPE
302       */
303      public void testAddAll1() {
304 +        ArrayDeque q = new ArrayDeque();
305          try {
294 –            ArrayDeque q = new ArrayDeque();
306              q.addAll(null);
307              shouldThrow();
308          } catch (NullPointerException success) {}
# Line 301 | Line 312 | public class ArrayDequeTest extends JSR1
312       * addAll of a collection with null elements throws NPE
313       */
314      public void testAddAll2() {
315 +        ArrayDeque q = new ArrayDeque();
316          try {
317 <            ArrayDeque q = new ArrayDeque();
306 <            Integer[] ints = new Integer[SIZE];
307 <            q.addAll(Arrays.asList(ints));
317 >            q.addAll(Arrays.asList(new Integer[SIZE]));
318              shouldThrow();
319          } catch (NullPointerException success) {}
320      }
# Line 314 | Line 324 | public class ArrayDequeTest extends JSR1
324       * possibly adding some elements
325       */
326      public void testAddAll3() {
327 +        ArrayDeque q = new ArrayDeque();
328 +        Integer[] ints = new Integer[SIZE];
329 +        for (int i = 0; i < SIZE - 1; ++i)
330 +            ints[i] = new Integer(i);
331          try {
318 –            ArrayDeque q = new ArrayDeque();
319 –            Integer[] ints = new Integer[SIZE];
320 –            for (int i = 0; i < SIZE-1; ++i)
321 –                ints[i] = new Integer(i);
332              q.addAll(Arrays.asList(ints));
333              shouldThrow();
334          } catch (NullPointerException success) {}
# Line 355 | Line 365 | public class ArrayDequeTest extends JSR1
365       */
366      public void testPollLast() {
367          ArrayDeque q = populatedDeque(SIZE);
368 <        for (int i = SIZE-1; i >= 0; --i) {
368 >        for (int i = SIZE - 1; i >= 0; --i) {
369              assertEquals(i, q.pollLast());
370          }
371          assertNull(q.pollLast());
# Line 391 | Line 401 | public class ArrayDequeTest extends JSR1
401       */
402      public void testRemoveElement() {
403          ArrayDeque q = populatedDeque(SIZE);
404 <        for (int i = 1; i < SIZE; i+=2) {
404 >        for (int i = 1; i < SIZE; i += 2) {
405              assertTrue(q.contains(i));
406              assertTrue(q.remove(i));
407              assertFalse(q.contains(i));
408 <            assertTrue(q.contains(i-1));
408 >            assertTrue(q.contains(i - 1));
409          }
410 <        for (int i = 0; i < SIZE; i+=2) {
410 >        for (int i = 0; i < SIZE; i += 2) {
411              assertTrue(q.contains(i));
412              assertTrue(q.remove(i));
413              assertFalse(q.contains(i));
414 <            assertFalse(q.remove(i+1));
415 <            assertFalse(q.contains(i+1));
414 >            assertFalse(q.remove(i + 1));
415 >            assertFalse(q.contains(i + 1));
416          }
417          assertTrue(q.isEmpty());
418      }
# Line 440 | Line 450 | public class ArrayDequeTest extends JSR1
450       */
451      public void testPeekLast() {
452          ArrayDeque q = populatedDeque(SIZE);
453 <        for (int i = SIZE-1; i >= 0; --i) {
453 >        for (int i = SIZE - 1; i >= 0; --i) {
454              assertEquals(i, q.peekLast());
455              assertEquals(i, q.pollLast());
456              assertTrue(q.peekLast() == null ||
# Line 484 | Line 494 | public class ArrayDequeTest extends JSR1
494       */
495      public void testLastElement() {
496          ArrayDeque q = populatedDeque(SIZE);
497 <        for (int i = SIZE-1; i >= 0; --i) {
497 >        for (int i = SIZE - 1; i >= 0; --i) {
498              assertEquals(i, q.getLast());
499              assertEquals(i, q.pollLast());
500          }
# Line 530 | Line 540 | public class ArrayDequeTest extends JSR1
540       */
541      public void testRemoveFirstOccurrence() {
542          ArrayDeque q = populatedDeque(SIZE);
543 <        for (int i = 1; i < SIZE; i+=2) {
543 >        assertFalse(q.removeFirstOccurrence(null));
544 >        for (int i = 1; i < SIZE; i += 2) {
545              assertTrue(q.removeFirstOccurrence(new Integer(i)));
546          }
547 <        for (int i = 0; i < SIZE; i+=2) {
547 >        for (int i = 0; i < SIZE; i += 2) {
548              assertTrue(q.removeFirstOccurrence(new Integer(i)));
549 <            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
549 >            assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
550          }
551          assertTrue(q.isEmpty());
552 +        assertFalse(q.removeFirstOccurrence(null));
553 +        assertFalse(q.removeFirstOccurrence(42));
554 +        q = new ArrayDeque();
555 +        assertFalse(q.removeFirstOccurrence(null));
556 +        assertFalse(q.removeFirstOccurrence(42));
557      }
558  
559      /**
# Line 545 | Line 561 | public class ArrayDequeTest extends JSR1
561       */
562      public void testRemoveLastOccurrence() {
563          ArrayDeque q = populatedDeque(SIZE);
564 <        for (int i = 1; i < SIZE; i+=2) {
564 >        assertFalse(q.removeLastOccurrence(null));
565 >        for (int i = 1; i < SIZE; i += 2) {
566              assertTrue(q.removeLastOccurrence(new Integer(i)));
567          }
568 <        for (int i = 0; i < SIZE; i+=2) {
568 >        for (int i = 0; i < SIZE; i += 2) {
569              assertTrue(q.removeLastOccurrence(new Integer(i)));
570 <            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
570 >            assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
571          }
572          assertTrue(q.isEmpty());
573 +        assertFalse(q.removeLastOccurrence(null));
574 +        assertFalse(q.removeLastOccurrence(42));
575 +        q = new ArrayDeque();
576 +        assertFalse(q.removeLastOccurrence(null));
577 +        assertFalse(q.removeLastOccurrence(42));
578      }
579  
580      /**
# Line 605 | Line 627 | public class ArrayDequeTest extends JSR1
627              boolean changed = q.retainAll(p);
628              assertEquals(changed, (i > 0));
629              assertTrue(q.containsAll(p));
630 <            assertEquals(SIZE-i, q.size());
630 >            assertEquals(SIZE - i, q.size());
631              p.removeFirst();
632          }
633      }
# Line 618 | Line 640 | public class ArrayDequeTest extends JSR1
640              ArrayDeque q = populatedDeque(SIZE);
641              ArrayDeque p = populatedDeque(i);
642              assertTrue(q.removeAll(p));
643 <            assertEquals(SIZE-i, q.size());
643 >            assertEquals(SIZE - i, q.size());
644              for (int j = 0; j < i; ++j) {
645                  assertFalse(q.contains(p.removeFirst()));
646              }
647          }
648      }
649  
650 +    void checkToArray(ArrayDeque q) {
651 +        int size = q.size();
652 +        Object[] o = q.toArray();
653 +        assertEquals(size, o.length);
654 +        Iterator it = q.iterator();
655 +        for (int i = 0; i < size; i++) {
656 +            Integer x = (Integer) it.next();
657 +            assertEquals((Integer)o[0] + i, (int) x);
658 +            assertSame(o[i], x);
659 +        }
660 +    }
661 +
662      /**
663       * toArray() contains all elements in FIFO order
664       */
665      public void testToArray() {
666 <        ArrayDeque q = populatedDeque(SIZE);
667 <        Object[] o = q.toArray();
668 <        for (int i = 0; i < o.length; i++)
669 <            assertSame(o[i], q.pollFirst());
666 >        ArrayDeque q = new ArrayDeque();
667 >        for (int i = 0; i < SIZE; i++) {
668 >            checkToArray(q);
669 >            q.addLast(i);
670 >        }
671 >        // Provoke wraparound
672 >        for (int i = 0; i < SIZE; i++) {
673 >            checkToArray(q);
674 >            assertEquals(i, q.poll());
675 >            q.addLast(SIZE + i);
676 >        }
677 >        for (int i = 0; i < SIZE; i++) {
678 >            checkToArray(q);
679 >            assertEquals(SIZE + i, q.poll());
680 >        }
681 >    }
682 >
683 >    void checkToArray2(ArrayDeque q) {
684 >        int size = q.size();
685 >        Integer[] a1 = (size == 0) ? null : new Integer[size - 1];
686 >        Integer[] a2 = new Integer[size];
687 >        Integer[] a3 = new Integer[size + 2];
688 >        if (size > 0) Arrays.fill(a1, 42);
689 >        Arrays.fill(a2, 42);
690 >        Arrays.fill(a3, 42);
691 >        Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);
692 >        Integer[] b2 = (Integer[]) q.toArray(a2);
693 >        Integer[] b3 = (Integer[]) q.toArray(a3);
694 >        assertSame(a2, b2);
695 >        assertSame(a3, b3);
696 >        Iterator it = q.iterator();
697 >        for (int i = 0; i < size; i++) {
698 >            Integer x = (Integer) it.next();
699 >            assertSame(b1[i], x);
700 >            assertEquals(b1[0] + i, (int) x);
701 >            assertSame(b2[i], x);
702 >            assertSame(b3[i], x);
703 >        }
704 >        assertNull(a3[size]);
705 >        assertEquals(42, (int) a3[size + 1]);
706 >        if (size > 0) {
707 >            assertNotSame(a1, b1);
708 >            assertEquals(size, b1.length);
709 >            for (int i = 0; i < a1.length; i++) {
710 >                assertEquals(42, (int) a1[i]);
711 >            }
712 >        }
713      }
714  
715      /**
716       * toArray(a) contains all elements in FIFO order
717       */
718      public void testToArray2() {
719 <        ArrayDeque<Integer> q = populatedDeque(SIZE);
720 <        Integer[] ints = new Integer[SIZE];
721 <        Integer[] array = q.toArray(ints);
722 <        assertSame(ints, array);
723 <        for (int i = 0; i < ints.length; i++)
724 <            assertSame(ints[i], q.remove());
719 >        ArrayDeque q = new ArrayDeque();
720 >        for (int i = 0; i < SIZE; i++) {
721 >            checkToArray2(q);
722 >            q.addLast(i);
723 >        }
724 >        // Provoke wraparound
725 >        for (int i = 0; i < SIZE; i++) {
726 >            checkToArray2(q);
727 >            assertEquals(i, q.poll());
728 >            q.addLast(SIZE + i);
729 >        }
730 >        for (int i = 0; i < SIZE; i++) {
731 >            checkToArray2(q);
732 >            assertEquals(SIZE + i, q.poll());
733 >        }
734      }
735  
736      /**
# Line 676 | Line 762 | public class ArrayDequeTest extends JSR1
762       */
763      public void testIterator() {
764          ArrayDeque q = populatedDeque(SIZE);
679 –        int i = 0;
765          Iterator it = q.iterator();
766 <        while (it.hasNext()) {
766 >        int i;
767 >        for (i = 0; it.hasNext(); i++)
768              assertTrue(q.contains(it.next()));
683 –            ++i;
684 –        }
769          assertEquals(i, SIZE);
770 +        assertIteratorExhausted(it);
771 +    }
772 +
773 +    /**
774 +     * iterator of empty collection has no elements
775 +     */
776 +    public void testEmptyIterator() {
777 +        Deque c = new ArrayDeque();
778 +        assertIteratorExhausted(c.iterator());
779 +        assertIteratorExhausted(c.descendingIterator());
780      }
781  
782      /**
# Line 709 | Line 803 | public class ArrayDequeTest extends JSR1
803          final Random rng = new Random();
804          for (int iters = 0; iters < 100; ++iters) {
805              int max = rng.nextInt(5) + 2;
806 <            int split = rng.nextInt(max-1) + 1;
806 >            int split = rng.nextInt(max - 1) + 1;
807              for (int j = 1; j <= max; ++j)
808                  q.add(new Integer(j));
809              Iterator it = q.iterator();
810              for (int j = 1; j <= split; ++j)
811                  assertEquals(it.next(), new Integer(j));
812              it.remove();
813 <            assertEquals(it.next(), new Integer(split+1));
813 >            assertEquals(it.next(), new Integer(split + 1));
814              for (int j = 1; j <= split; ++j)
815                  q.remove(new Integer(j));
816              it = q.iterator();
817 <            for (int j = split+1; j <= max; ++j) {
817 >            for (int j = split + 1; j <= max; ++j) {
818                  assertEquals(it.next(), new Integer(j));
819                  it.remove();
820              }
# Line 777 | Line 871 | public class ArrayDequeTest extends JSR1
871          final Random rng = new Random();
872          for (int iters = 0; iters < 100; ++iters) {
873              int max = rng.nextInt(5) + 2;
874 <            int split = rng.nextInt(max-1) + 1;
874 >            int split = rng.nextInt(max - 1) + 1;
875              for (int j = max; j >= 1; --j)
876                  q.add(new Integer(j));
877              Iterator it = q.descendingIterator();
878              for (int j = 1; j <= split; ++j)
879                  assertEquals(it.next(), new Integer(j));
880              it.remove();
881 <            assertEquals(it.next(), new Integer(split+1));
881 >            assertEquals(it.next(), new Integer(split + 1));
882              for (int j = 1; j <= split; ++j)
883                  q.remove(new Integer(j));
884              it = q.descendingIterator();
885 <            for (int j = split+1; j <= max; ++j) {
885 >            for (int j = split + 1; j <= max; ++j) {
886                  assertEquals(it.next(), new Integer(j));
887                  it.remove();
888              }
# Line 815 | Line 909 | public class ArrayDequeTest extends JSR1
909          Queue x = populatedDeque(SIZE);
910          Queue y = serialClone(x);
911  
912 <        assertTrue(x != y);
912 >        assertNotSame(y, x);
913          assertEquals(x.size(), y.size());
914          assertEquals(x.toString(), y.toString());
915          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 826 | Line 920 | public class ArrayDequeTest extends JSR1
920          assertTrue(y.isEmpty());
921      }
922  
923 +    /**
924 +     * remove(null), contains(null) always return false
925 +     */
926 +    public void testNeverContainsNull() {
927 +        Deque<?>[] qs = {
928 +            new ArrayDeque<Object>(),
929 +            populatedDeque(2),
930 +        };
931 +
932 +        for (Deque<?> q : qs) {
933 +            assertFalse(q.contains(null));
934 +            assertFalse(q.remove(null));
935 +            assertFalse(q.removeFirstOccurrence(null));
936 +            assertFalse(q.removeLastOccurrence(null));
937 +        }
938 +    }
939 +
940   }

Diff Legend

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