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

Comparing jsr166/src/test/tck/ConcurrentLinkedDequeTest.java (file contents):
Revision 1.20 by jsr166, Fri May 15 18:21:19 2015 UTC vs.
Revision 1.28 by jsr166, Mon May 29 22:44:26 2017 UTC

# Line 16 | Line 16 | import java.util.Random;
16   import java.util.concurrent.ConcurrentLinkedDeque;
17  
18   import junit.framework.Test;
19 – import junit.framework.TestSuite;
19  
20   public class ConcurrentLinkedDequeTest extends JSR166TestCase {
21  
# Line 25 | Line 24 | public class ConcurrentLinkedDequeTest e
24      }
25  
26      public static Test suite() {
27 <        return new TestSuite(ConcurrentLinkedDequeTest.class);
27 >        class Implementation implements CollectionImplementation {
28 >            public Class<?> klazz() { return ConcurrentLinkedDeque.class; }
29 >            public Collection emptyCollection() { return new ConcurrentLinkedDeque(); }
30 >            public Object makeElement(int i) { return i; }
31 >            public boolean isConcurrent() { return true; }
32 >            public boolean permitsNulls() { return false; }
33 >        }
34 >        return newTestSuite(ConcurrentLinkedDequeTest.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 ConcurrentLinkedDeque<Integer> populatedDeque(int n) {
43 <        ConcurrentLinkedDeque<Integer> q = new ConcurrentLinkedDeque<Integer>();
42 >    private static ConcurrentLinkedDeque<Integer> populatedDeque(int n) {
43 >        ConcurrentLinkedDeque<Integer> q = new ConcurrentLinkedDeque<>();
44          assertTrue(q.isEmpty());
45          for (int i = 0; i < n; ++i)
46              assertTrue(q.offer(new Integer(i)));
47          assertFalse(q.isEmpty());
48          assertEquals(n, q.size());
49 +        assertEquals((Integer) 0, q.peekFirst());
50 +        assertEquals((Integer) (n - 1), q.peekLast());
51          return q;
52      }
53  
# Line 75 | Line 84 | public class ConcurrentLinkedDequeTest e
84       */
85      public void testConstructor5() {
86          Integer[] ints = new Integer[SIZE];
87 <        for (int i = 0; i < SIZE-1; ++i)
87 >        for (int i = 0; i < SIZE - 1; ++i)
88              ints[i] = new Integer(i);
89          try {
90              new ConcurrentLinkedDeque(Arrays.asList(ints));
# Line 115 | Line 124 | public class ConcurrentLinkedDequeTest e
124      public void testSize() {
125          ConcurrentLinkedDeque q = populatedDeque(SIZE);
126          for (int i = 0; i < SIZE; ++i) {
127 <            assertEquals(SIZE-i, q.size());
127 >            assertEquals(SIZE - i, q.size());
128              q.remove();
129          }
130          for (int i = 0; i < SIZE; ++i) {
# Line 303 | Line 312 | public class ConcurrentLinkedDequeTest e
312      }
313  
314      /**
315 <     * addAll(this) throws IAE
315 >     * addAll(this) throws IllegalArgumentException
316       */
317      public void testAddAllSelf() {
318          ConcurrentLinkedDeque q = populatedDeque(SIZE);
# Line 331 | Line 340 | public class ConcurrentLinkedDequeTest e
340      public void testAddAll3() {
341          ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
342          Integer[] ints = new Integer[SIZE];
343 <        for (int i = 0; i < SIZE-1; ++i)
343 >        for (int i = 0; i < SIZE - 1; ++i)
344              ints[i] = new Integer(i);
345          try {
346              q.addAll(Arrays.asList(ints));
# Line 370 | Line 379 | public class ConcurrentLinkedDequeTest e
379       */
380      public void testPollLast() {
381          ConcurrentLinkedDeque q = populatedDeque(SIZE);
382 <        for (int i = SIZE-1; i >= 0; --i) {
382 >        for (int i = SIZE - 1; i >= 0; --i) {
383              assertEquals(i, q.pollLast());
384          }
385          assertNull(q.pollLast());
# Line 439 | Line 448 | public class ConcurrentLinkedDequeTest e
448              assertTrue(q.contains(i));
449              assertTrue(q.remove(i));
450              assertFalse(q.contains(i));
451 <            assertTrue(q.contains(i-1));
451 >            assertTrue(q.contains(i - 1));
452          }
453          for (int i = 0; i < SIZE; i += 2) {
454              assertTrue(q.contains(i));
455              assertTrue(q.remove(i));
456              assertFalse(q.contains(i));
457 <            assertFalse(q.remove(i+1));
458 <            assertFalse(q.contains(i+1));
457 >            assertFalse(q.remove(i + 1));
458 >            assertFalse(q.contains(i + 1));
459          }
460          assertTrue(q.isEmpty());
461      }
# Line 470 | Line 479 | public class ConcurrentLinkedDequeTest e
479       */
480      public void testPeekLast() {
481          ConcurrentLinkedDeque 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 499 | Line 508 | public class ConcurrentLinkedDequeTest e
508       */
509      public void testLastElement() {
510          ConcurrentLinkedDeque q = populatedDeque(SIZE);
511 <        for (int i = SIZE-1; i >= 0; --i) {
511 >        for (int i = SIZE - 1; i >= 0; --i) {
512              assertEquals(i, q.getLast());
513              assertEquals(i, q.pollLast());
514          }
# Line 550 | Line 559 | public class ConcurrentLinkedDequeTest e
559          }
560          for (int i = 0; i < SIZE; i += 2) {
561              assertTrue(q.removeFirstOccurrence(new Integer(i)));
562 <            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
562 >            assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
563          }
564          assertTrue(q.isEmpty());
565      }
# Line 565 | Line 574 | public class ConcurrentLinkedDequeTest e
574          }
575          for (int i = 0; i < SIZE; i += 2) {
576              assertTrue(q.removeLastOccurrence(new Integer(i)));
577 <            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
577 >            assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
578          }
579          assertTrue(q.isEmpty());
580      }
# Line 624 | Line 633 | public class ConcurrentLinkedDequeTest e
633                  assertTrue(changed);
634  
635              assertTrue(q.containsAll(p));
636 <            assertEquals(SIZE-i, q.size());
636 >            assertEquals(SIZE - i, q.size());
637              p.remove();
638          }
639      }
# Line 637 | Line 646 | public class ConcurrentLinkedDequeTest e
646              ConcurrentLinkedDeque q = populatedDeque(SIZE);
647              ConcurrentLinkedDeque p = populatedDeque(i);
648              assertTrue(q.removeAll(p));
649 <            assertEquals(SIZE-i, q.size());
649 >            assertEquals(SIZE - i, q.size());
650              for (int j = 0; j < i; ++j) {
651                  Integer x = (Integer)(p.remove());
652                  assertFalse(q.contains(x));
# Line 753 | Line 762 | public class ConcurrentLinkedDequeTest e
762          final Random rng = new Random();
763          for (int iters = 0; iters < 100; ++iters) {
764              int max = rng.nextInt(5) + 2;
765 <            int split = rng.nextInt(max-1) + 1;
765 >            int split = rng.nextInt(max - 1) + 1;
766              for (int j = 1; j <= max; ++j)
767                  q.add(new Integer(j));
768              Iterator it = q.iterator();
769              for (int j = 1; j <= split; ++j)
770                  assertEquals(it.next(), new Integer(j));
771              it.remove();
772 <            assertEquals(it.next(), new Integer(split+1));
772 >            assertEquals(it.next(), new Integer(split + 1));
773              for (int j = 1; j <= split; ++j)
774                  q.remove(new Integer(j));
775              it = q.iterator();
776 <            for (int j = split+1; j <= max; ++j) {
776 >            for (int j = split + 1; j <= max; ++j) {
777                  assertEquals(it.next(), new Integer(j));
778                  it.remove();
779              }
# Line 821 | Line 830 | public class ConcurrentLinkedDequeTest e
830          final Random rng = new Random();
831          for (int iters = 0; iters < 100; ++iters) {
832              int max = rng.nextInt(5) + 2;
833 <            int split = rng.nextInt(max-1) + 1;
833 >            int split = rng.nextInt(max - 1) + 1;
834              for (int j = max; j >= 1; --j)
835                  q.add(new Integer(j));
836              Iterator it = q.descendingIterator();
837              for (int j = 1; j <= split; ++j)
838                  assertEquals(it.next(), new Integer(j));
839              it.remove();
840 <            assertEquals(it.next(), new Integer(split+1));
840 >            assertEquals(it.next(), new Integer(split + 1));
841              for (int j = 1; j <= split; ++j)
842                  q.remove(new Integer(j));
843              it = q.descendingIterator();
844 <            for (int j = split+1; j <= max; ++j) {
844 >            for (int j = split + 1; j <= max; ++j) {
845                  assertEquals(it.next(), new Integer(j));
846                  it.remove();
847              }

Diff Legend

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