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.25 by jsr166, Tue Feb 21 01:54:03 2012 UTC vs.
Revision 1.33 by jsr166, Sun Feb 22 04:34:44 2015 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());
# Line 24 | Line 26 | public class ArrayDequeTest extends JSR1
26      }
27  
28      /**
29 <     * Creates a deque of given size containing consecutive
29 >     * Returns a new deque of given size containing consecutive
30       * Integers 0 ... n.
31       */
32      private ArrayDeque<Integer> populatedDeque(int n) {
# Line 49 | Line 51 | public class ArrayDequeTest extends JSR1
51       */
52      public void testConstructor3() {
53          try {
54 <            ArrayDeque q = new ArrayDeque((Collection)null);
54 >            new ArrayDeque((Collection)null);
55              shouldThrow();
56          } catch (NullPointerException success) {}
57      }
# Line 60 | Line 62 | public class ArrayDequeTest extends JSR1
62      public void testConstructor4() {
63          try {
64              Integer[] ints = new Integer[SIZE];
65 <            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
65 >            new ArrayDeque(Arrays.asList(ints));
66              shouldThrow();
67          } catch (NullPointerException success) {}
68      }
# Line 73 | Line 75 | public class ArrayDequeTest extends JSR1
75              Integer[] ints = new Integer[SIZE];
76              for (int i = 0; i < SIZE-1; ++i)
77                  ints[i] = new Integer(i);
78 <            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
78 >            new ArrayDeque(Arrays.asList(ints));
79              shouldThrow();
80          } catch (NullPointerException success) {}
81      }
# Line 391 | Line 393 | public class ArrayDequeTest extends JSR1
393       */
394      public void testRemoveElement() {
395          ArrayDeque q = populatedDeque(SIZE);
396 <        for (int i = 1; i < SIZE; i+=2) {
396 >        for (int i = 1; i < SIZE; i += 2) {
397              assertTrue(q.contains(i));
398              assertTrue(q.remove(i));
399              assertFalse(q.contains(i));
400              assertTrue(q.contains(i-1));
401          }
402 <        for (int i = 0; i < SIZE; i+=2) {
402 >        for (int i = 0; i < SIZE; i += 2) {
403              assertTrue(q.contains(i));
404              assertTrue(q.remove(i));
405              assertFalse(q.contains(i));
# Line 530 | Line 532 | public class ArrayDequeTest extends JSR1
532       */
533      public void testRemoveFirstOccurrence() {
534          ArrayDeque q = populatedDeque(SIZE);
535 <        for (int i = 1; i < SIZE; i+=2) {
535 >        for (int i = 1; i < SIZE; i += 2) {
536              assertTrue(q.removeFirstOccurrence(new Integer(i)));
537          }
538 <        for (int i = 0; i < SIZE; i+=2) {
538 >        for (int i = 0; i < SIZE; i += 2) {
539              assertTrue(q.removeFirstOccurrence(new Integer(i)));
540              assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
541          }
# Line 545 | Line 547 | public class ArrayDequeTest extends JSR1
547       */
548      public void testRemoveLastOccurrence() {
549          ArrayDeque q = populatedDeque(SIZE);
550 <        for (int i = 1; i < SIZE; i+=2) {
550 >        for (int i = 1; i < SIZE; i += 2) {
551              assertTrue(q.removeLastOccurrence(new Integer(i)));
552          }
553 <        for (int i = 0; i < SIZE; i+=2) {
553 >        for (int i = 0; i < SIZE; i += 2) {
554              assertTrue(q.removeLastOccurrence(new Integer(i)));
555              assertFalse(q.removeLastOccurrence(new Integer(i+1)));
556          }
# Line 625 | Line 627 | public class ArrayDequeTest extends JSR1
627          }
628      }
629  
630 +    void checkToArray(ArrayDeque q) {
631 +        int size = q.size();
632 +        Object[] o = q.toArray();
633 +        assertEquals(size, o.length);
634 +        Iterator it = q.iterator();
635 +        for (int i = 0; i < size; i++) {
636 +            Integer x = (Integer) it.next();
637 +            assertEquals((Integer)o[0] + i, (int) x);
638 +            assertSame(o[i], x);
639 +        }
640 +    }
641 +
642      /**
643       * toArray() contains all elements in FIFO order
644       */
645      public void testToArray() {
646 <        ArrayDeque q = populatedDeque(SIZE);
647 <        Object[] o = q.toArray();
648 <        for (int i = 0; i < o.length; i++)
649 <            assertSame(o[i], q.pollFirst());
646 >        ArrayDeque q = new ArrayDeque();
647 >        for (int i = 0; i < SIZE; i++) {
648 >            checkToArray(q);
649 >            q.addLast(i);
650 >        }
651 >        // Provoke wraparound
652 >        for (int i = 0; i < SIZE; i++) {
653 >            checkToArray(q);
654 >            assertEquals(i, q.poll());
655 >            q.addLast(SIZE+i);
656 >        }
657 >        for (int i = 0; i < SIZE; i++) {
658 >            checkToArray(q);
659 >            assertEquals(SIZE+i, q.poll());
660 >        }
661 >    }
662 >
663 >    void checkToArray2(ArrayDeque q) {
664 >        int size = q.size();
665 >        Integer[] a1 = size == 0 ? null : new Integer[size-1];
666 >        Integer[] a2 = new Integer[size];
667 >        Integer[] a3 = new Integer[size+2];
668 >        if (size > 0) Arrays.fill(a1, 42);
669 >        Arrays.fill(a2, 42);
670 >        Arrays.fill(a3, 42);
671 >        Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
672 >        Integer[] b2 = (Integer[]) q.toArray(a2);
673 >        Integer[] b3 = (Integer[]) q.toArray(a3);
674 >        assertSame(a2, b2);
675 >        assertSame(a3, b3);
676 >        Iterator it = q.iterator();
677 >        for (int i = 0; i < size; i++) {
678 >            Integer x = (Integer) it.next();
679 >            assertSame(b1[i], x);
680 >            assertEquals(b1[0] + i, (int) x);
681 >            assertSame(b2[i], x);
682 >            assertSame(b3[i], x);
683 >        }
684 >        assertNull(a3[size]);
685 >        assertEquals(42, (int) a3[size+1]);
686 >        if (size > 0) {
687 >            assertNotSame(a1, b1);
688 >            assertEquals(size, b1.length);
689 >            for (int i = 0; i < a1.length; i++) {
690 >                assertEquals(42, (int) a1[i]);
691 >            }
692 >        }
693      }
694  
695      /**
696       * toArray(a) contains all elements in FIFO order
697       */
698      public void testToArray2() {
699 <        ArrayDeque<Integer> q = populatedDeque(SIZE);
700 <        Integer[] ints = new Integer[SIZE];
701 <        Integer[] array = q.toArray(ints);
702 <        assertSame(ints, array);
703 <        for (int i = 0; i < ints.length; i++)
704 <            assertSame(ints[i], q.remove());
699 >        ArrayDeque q = new ArrayDeque();
700 >        for (int i = 0; i < SIZE; i++) {
701 >            checkToArray2(q);
702 >            q.addLast(i);
703 >        }
704 >        // Provoke wraparound
705 >        for (int i = 0; i < SIZE; i++) {
706 >            checkToArray2(q);
707 >            assertEquals(i, q.poll());
708 >            q.addLast(SIZE+i);
709 >        }
710 >        for (int i = 0; i < SIZE; i++) {
711 >            checkToArray2(q);
712 >            assertEquals(SIZE+i, q.poll());
713 >        }
714      }
715  
716      /**
# Line 676 | Line 742 | public class ArrayDequeTest extends JSR1
742       */
743      public void testIterator() {
744          ArrayDeque q = populatedDeque(SIZE);
679 –        int i = 0;
745          Iterator it = q.iterator();
746 <        while (it.hasNext()) {
746 >        int i;
747 >        for (i = 0; it.hasNext(); i++)
748              assertTrue(q.contains(it.next()));
683 –            ++i;
684 –        }
749          assertEquals(i, SIZE);
750 +        assertIteratorExhausted(it);
751 +    }
752 +
753 +    /**
754 +     * iterator of empty collection has no elements
755 +     */
756 +    public void testEmptyIterator() {
757 +        Deque c = new ArrayDeque();
758 +        assertIteratorExhausted(c.iterator());
759 +        assertIteratorExhausted(c.descendingIterator());
760      }
761  
762      /**
# Line 815 | Line 889 | public class ArrayDequeTest extends JSR1
889          Queue x = populatedDeque(SIZE);
890          Queue y = serialClone(x);
891  
892 <        assertTrue(x != y);
892 >        assertNotSame(y, x);
893          assertEquals(x.size(), y.size());
894          assertEquals(x.toString(), y.toString());
895          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 826 | Line 900 | public class ArrayDequeTest extends JSR1
900          assertTrue(y.isEmpty());
901      }
902  
903 +    /**
904 +     * remove(null), contains(null) always return false
905 +     */
906 +    public void testNeverContainsNull() {
907 +        Deque<?>[] qs = {
908 +            new ArrayDeque<Object>(),
909 +            populatedDeque(2),
910 +        };
911 +
912 +        for (Deque<?> q : qs) {
913 +            assertFalse(q.contains(null));
914 +            assertFalse(q.remove(null));
915 +            assertFalse(q.removeFirstOccurrence(null));
916 +            assertFalse(q.removeLastOccurrence(null));
917 +        }
918 +    }
919 +
920   }

Diff Legend

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