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.23 by jsr166, Sun Oct 16 20:16:36 2016 UTC

# Line 25 | Line 25 | public class ConcurrentLinkedDequeTest e
25      }
26  
27      public static Test suite() {
28 <        return new TestSuite(ConcurrentLinkedDequeTest.class);
28 >        class Implementation implements CollectionImplementation {
29 >            public Class<?> klazz() { return ConcurrentLinkedDeque.class; }
30 >            public Collection emptyCollection() { return new ConcurrentLinkedDeque(); }
31 >            public Object makeElement(int i) { return i; }
32 >            public boolean isConcurrent() { return true; }
33 >            public boolean permitsNulls() { return false; }
34 >        }
35 >        return newTestSuite(ConcurrentLinkedDequeTest.class,
36 >                            CollectionTest.testSuite(new Implementation()));
37      }
38  
39      /**
# Line 75 | Line 83 | public class ConcurrentLinkedDequeTest e
83       */
84      public void testConstructor5() {
85          Integer[] ints = new Integer[SIZE];
86 <        for (int i = 0; i < SIZE-1; ++i)
86 >        for (int i = 0; i < SIZE - 1; ++i)
87              ints[i] = new Integer(i);
88          try {
89              new ConcurrentLinkedDeque(Arrays.asList(ints));
# Line 115 | Line 123 | public class ConcurrentLinkedDequeTest e
123      public void testSize() {
124          ConcurrentLinkedDeque q = populatedDeque(SIZE);
125          for (int i = 0; i < SIZE; ++i) {
126 <            assertEquals(SIZE-i, q.size());
126 >            assertEquals(SIZE - i, q.size());
127              q.remove();
128          }
129          for (int i = 0; i < SIZE; ++i) {
# Line 331 | Line 339 | public class ConcurrentLinkedDequeTest e
339      public void testAddAll3() {
340          ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
341          Integer[] ints = new Integer[SIZE];
342 <        for (int i = 0; i < SIZE-1; ++i)
342 >        for (int i = 0; i < SIZE - 1; ++i)
343              ints[i] = new Integer(i);
344          try {
345              q.addAll(Arrays.asList(ints));
# Line 370 | Line 378 | public class ConcurrentLinkedDequeTest e
378       */
379      public void testPollLast() {
380          ConcurrentLinkedDeque q = populatedDeque(SIZE);
381 <        for (int i = SIZE-1; i >= 0; --i) {
381 >        for (int i = SIZE - 1; i >= 0; --i) {
382              assertEquals(i, q.pollLast());
383          }
384          assertNull(q.pollLast());
# Line 439 | Line 447 | public class ConcurrentLinkedDequeTest e
447              assertTrue(q.contains(i));
448              assertTrue(q.remove(i));
449              assertFalse(q.contains(i));
450 <            assertTrue(q.contains(i-1));
450 >            assertTrue(q.contains(i - 1));
451          }
452          for (int i = 0; i < SIZE; i += 2) {
453              assertTrue(q.contains(i));
454              assertTrue(q.remove(i));
455              assertFalse(q.contains(i));
456 <            assertFalse(q.remove(i+1));
457 <            assertFalse(q.contains(i+1));
456 >            assertFalse(q.remove(i + 1));
457 >            assertFalse(q.contains(i + 1));
458          }
459          assertTrue(q.isEmpty());
460      }
# Line 470 | Line 478 | public class ConcurrentLinkedDequeTest e
478       */
479      public void testPeekLast() {
480          ConcurrentLinkedDeque q = populatedDeque(SIZE);
481 <        for (int i = SIZE-1; i >= 0; --i) {
481 >        for (int i = SIZE - 1; i >= 0; --i) {
482              assertEquals(i, q.peekLast());
483              assertEquals(i, q.pollLast());
484              assertTrue(q.peekLast() == null ||
# Line 499 | Line 507 | public class ConcurrentLinkedDequeTest e
507       */
508      public void testLastElement() {
509          ConcurrentLinkedDeque q = populatedDeque(SIZE);
510 <        for (int i = SIZE-1; i >= 0; --i) {
510 >        for (int i = SIZE - 1; i >= 0; --i) {
511              assertEquals(i, q.getLast());
512              assertEquals(i, q.pollLast());
513          }
# Line 550 | Line 558 | public class ConcurrentLinkedDequeTest e
558          }
559          for (int i = 0; i < SIZE; i += 2) {
560              assertTrue(q.removeFirstOccurrence(new Integer(i)));
561 <            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
561 >            assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
562          }
563          assertTrue(q.isEmpty());
564      }
# Line 565 | Line 573 | public class ConcurrentLinkedDequeTest e
573          }
574          for (int i = 0; i < SIZE; i += 2) {
575              assertTrue(q.removeLastOccurrence(new Integer(i)));
576 <            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
576 >            assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
577          }
578          assertTrue(q.isEmpty());
579      }
# Line 624 | Line 632 | public class ConcurrentLinkedDequeTest e
632                  assertTrue(changed);
633  
634              assertTrue(q.containsAll(p));
635 <            assertEquals(SIZE-i, q.size());
635 >            assertEquals(SIZE - i, q.size());
636              p.remove();
637          }
638      }
# Line 637 | Line 645 | public class ConcurrentLinkedDequeTest e
645              ConcurrentLinkedDeque q = populatedDeque(SIZE);
646              ConcurrentLinkedDeque p = populatedDeque(i);
647              assertTrue(q.removeAll(p));
648 <            assertEquals(SIZE-i, q.size());
648 >            assertEquals(SIZE - i, q.size());
649              for (int j = 0; j < i; ++j) {
650                  Integer x = (Integer)(p.remove());
651                  assertFalse(q.contains(x));
# Line 753 | Line 761 | public class ConcurrentLinkedDequeTest e
761          final Random rng = new Random();
762          for (int iters = 0; iters < 100; ++iters) {
763              int max = rng.nextInt(5) + 2;
764 <            int split = rng.nextInt(max-1) + 1;
764 >            int split = rng.nextInt(max - 1) + 1;
765              for (int j = 1; j <= max; ++j)
766                  q.add(new Integer(j));
767              Iterator it = q.iterator();
768              for (int j = 1; j <= split; ++j)
769                  assertEquals(it.next(), new Integer(j));
770              it.remove();
771 <            assertEquals(it.next(), new Integer(split+1));
771 >            assertEquals(it.next(), new Integer(split + 1));
772              for (int j = 1; j <= split; ++j)
773                  q.remove(new Integer(j));
774              it = q.iterator();
775 <            for (int j = split+1; j <= max; ++j) {
775 >            for (int j = split + 1; j <= max; ++j) {
776                  assertEquals(it.next(), new Integer(j));
777                  it.remove();
778              }
# Line 821 | Line 829 | public class ConcurrentLinkedDequeTest e
829          final Random rng = new Random();
830          for (int iters = 0; iters < 100; ++iters) {
831              int max = rng.nextInt(5) + 2;
832 <            int split = rng.nextInt(max-1) + 1;
832 >            int split = rng.nextInt(max - 1) + 1;
833              for (int j = max; j >= 1; --j)
834                  q.add(new Integer(j));
835              Iterator it = q.descendingIterator();
836              for (int j = 1; j <= split; ++j)
837                  assertEquals(it.next(), new Integer(j));
838              it.remove();
839 <            assertEquals(it.next(), new Integer(split+1));
839 >            assertEquals(it.next(), new Integer(split + 1));
840              for (int j = 1; j <= split; ++j)
841                  q.remove(new Integer(j));
842              it = q.descendingIterator();
843 <            for (int j = split+1; j <= max; ++j) {
843 >            for (int j = split + 1; j <= max; ++j) {
844                  assertEquals(it.next(), new Integer(j));
845                  it.remove();
846              }

Diff Legend

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