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

Comparing jsr166/src/test/tck/ConcurrentSkipListSubSetTest.java (file contents):
Revision 1.27 by jsr166, Wed Dec 31 20:09:08 2014 UTC vs.
Revision 1.33 by jsr166, Sat May 23 00:53:08 2015 UTC

# Line 16 | Line 16 | import junit.framework.TestSuite;
16  
17   public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
18      public static void main(String[] args) {
19 <        junit.textui.TestRunner.run(suite());
19 >        main(suite(), args);
20      }
21      public static Test suite() {
22          return new TestSuite(ConcurrentSkipListSubSetTest.class);
# Line 122 | Line 122 | public class ConcurrentSkipListSubSetTes
122      public void testSize() {
123          NavigableSet q = populatedSet(SIZE);
124          for (int i = 0; i < SIZE; ++i) {
125 <            assertEquals(SIZE-i, q.size());
125 >            assertEquals(SIZE - i, q.size());
126              q.pollFirst();
127          }
128          for (int i = 0; i < SIZE; ++i) {
# Line 135 | Line 135 | public class ConcurrentSkipListSubSetTes
135       * add(null) throws NPE
136       */
137      public void testAddNull() {
138 +        NavigableSet q = set0();
139          try {
139 –            NavigableSet q = set0();
140              q.add(null);
141              shouldThrow();
142          } catch (NullPointerException success) {}
# Line 163 | Line 163 | public class ConcurrentSkipListSubSetTes
163       * Add of non-Comparable throws CCE
164       */
165      public void testAddNonComparable() {
166 +        NavigableSet q = set0();
167          try {
167 –            NavigableSet q = set0();
168 –            q.add(new Object());
168              q.add(new Object());
169              q.add(new Object());
170              shouldThrow();
# Line 176 | Line 175 | public class ConcurrentSkipListSubSetTes
175       * addAll(null) throws NPE
176       */
177      public void testAddAll1() {
178 +        NavigableSet q = set0();
179          try {
180 –            NavigableSet q = set0();
180              q.addAll(null);
181              shouldThrow();
182          } catch (NullPointerException success) {}
# Line 187 | Line 186 | public class ConcurrentSkipListSubSetTes
186       * addAll of a collection with null elements throws NPE
187       */
188      public void testAddAll2() {
189 +        NavigableSet q = set0();
190 +        Integer[] ints = new Integer[SIZE];
191          try {
191 –            NavigableSet q = set0();
192 –            Integer[] ints = new Integer[SIZE];
192              q.addAll(Arrays.asList(ints));
193              shouldThrow();
194          } catch (NullPointerException success) {}
# Line 200 | Line 199 | public class ConcurrentSkipListSubSetTes
199       * possibly adding some elements
200       */
201      public void testAddAll3() {
202 +        NavigableSet q = set0();
203 +        Integer[] ints = new Integer[SIZE];
204 +        for (int i = 0; i < SIZE - 1; ++i)
205 +            ints[i] = new Integer(i + SIZE);
206          try {
204 –            NavigableSet q = set0();
205 –            Integer[] ints = new Integer[SIZE];
206 –            for (int i = 0; i < SIZE-1; ++i)
207 –                ints[i] = new Integer(i+SIZE);
207              q.addAll(Arrays.asList(ints));
208              shouldThrow();
209          } catch (NullPointerException success) {}
# Line 217 | Line 216 | public class ConcurrentSkipListSubSetTes
216          Integer[] empty = new Integer[0];
217          Integer[] ints = new Integer[SIZE];
218          for (int i = 0; i < SIZE; ++i)
219 <            ints[i] = new Integer(SIZE-1- i);
219 >            ints[i] = new Integer(SIZE - 1 - i);
220          NavigableSet q = set0();
221          assertFalse(q.addAll(Arrays.asList(empty)));
222          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 311 | Line 310 | public class ConcurrentSkipListSubSetTes
310                  assertTrue(changed);
311  
312              assertTrue(q.containsAll(p));
313 <            assertEquals(SIZE-i, q.size());
313 >            assertEquals(SIZE - i, q.size());
314              p.pollFirst();
315          }
316      }
# Line 324 | Line 323 | public class ConcurrentSkipListSubSetTes
323              NavigableSet q = populatedSet(SIZE);
324              NavigableSet p = populatedSet(i);
325              assertTrue(q.removeAll(p));
326 <            assertEquals(SIZE-i, q.size());
326 >            assertEquals(SIZE - i, q.size());
327              for (int j = 0; j < i; ++j) {
328 <                Integer I = (Integer)(p.pollFirst());
329 <                assertFalse(q.contains(I));
328 >                Integer x = (Integer)(p.pollFirst());
329 >                assertFalse(q.contains(x));
330              }
331          }
332      }
# Line 431 | Line 430 | public class ConcurrentSkipListSubSetTes
430       */
431      public void testIterator() {
432          NavigableSet q = populatedSet(SIZE);
434 –        int i = 0;
433          Iterator it = q.iterator();
434 <        while (it.hasNext()) {
434 >        int i;
435 >        for (i = 0; it.hasNext(); i++)
436              assertTrue(q.contains(it.next()));
438 –            ++i;
439 –        }
437          assertEquals(i, SIZE);
438 +        assertIteratorExhausted(it);
439      }
440  
441      /**
442       * iterator of empty set has no elements
443       */
444      public void testEmptyIterator() {
445 <        NavigableSet q = set0();
448 <        int i = 0;
449 <        Iterator it = q.iterator();
450 <        while (it.hasNext()) {
451 <            assertTrue(q.contains(it.next()));
452 <            ++i;
453 <        }
454 <        assertEquals(0, i);
445 >        assertIteratorExhausted(set0().iterator());
446      }
447  
448      /**
# Line 627 | Line 618 | public class ConcurrentSkipListSubSetTes
618      public void testDescendingSize() {
619          NavigableSet q = populatedSet(SIZE);
620          for (int i = 0; i < SIZE; ++i) {
621 <            assertEquals(SIZE-i, q.size());
621 >            assertEquals(SIZE - i, q.size());
622              q.pollFirst();
623          }
624          for (int i = 0; i < SIZE; ++i) {
# Line 640 | Line 631 | public class ConcurrentSkipListSubSetTes
631       * add(null) throws NPE
632       */
633      public void testDescendingAddNull() {
634 +        NavigableSet q = dset0();
635          try {
644 –            NavigableSet q = dset0();
636              q.add(null);
637              shouldThrow();
638          } catch (NullPointerException success) {}
# Line 668 | Line 659 | public class ConcurrentSkipListSubSetTes
659       * Add of non-Comparable throws CCE
660       */
661      public void testDescendingAddNonComparable() {
662 +        NavigableSet q = dset0();
663          try {
672 –            NavigableSet q = dset0();
673 –            q.add(new Object());
664              q.add(new Object());
665              q.add(new Object());
666              shouldThrow();
# Line 681 | Line 671 | public class ConcurrentSkipListSubSetTes
671       * addAll(null) throws NPE
672       */
673      public void testDescendingAddAll1() {
674 +        NavigableSet q = dset0();
675          try {
685 –            NavigableSet q = dset0();
676              q.addAll(null);
677              shouldThrow();
678          } catch (NullPointerException success) {}
# Line 692 | Line 682 | public class ConcurrentSkipListSubSetTes
682       * addAll of a collection with null elements throws NPE
683       */
684      public void testDescendingAddAll2() {
685 +        NavigableSet q = dset0();
686 +        Integer[] ints = new Integer[SIZE];
687          try {
696 –            NavigableSet q = dset0();
697 –            Integer[] ints = new Integer[SIZE];
688              q.addAll(Arrays.asList(ints));
689              shouldThrow();
690          } catch (NullPointerException success) {}
# Line 705 | Line 695 | public class ConcurrentSkipListSubSetTes
695       * possibly adding some elements
696       */
697      public void testDescendingAddAll3() {
698 +        NavigableSet q = dset0();
699 +        Integer[] ints = new Integer[SIZE];
700 +        for (int i = 0; i < SIZE - 1; ++i)
701 +            ints[i] = new Integer(i + SIZE);
702          try {
709 –            NavigableSet q = dset0();
710 –            Integer[] ints = new Integer[SIZE];
711 –            for (int i = 0; i < SIZE-1; ++i)
712 –                ints[i] = new Integer(i+SIZE);
703              q.addAll(Arrays.asList(ints));
704              shouldThrow();
705          } catch (NullPointerException success) {}
# Line 722 | Line 712 | public class ConcurrentSkipListSubSetTes
712          Integer[] empty = new Integer[0];
713          Integer[] ints = new Integer[SIZE];
714          for (int i = 0; i < SIZE; ++i)
715 <            ints[i] = new Integer(SIZE-1- i);
715 >            ints[i] = new Integer(SIZE - 1 - i);
716          NavigableSet q = dset0();
717          assertFalse(q.addAll(Arrays.asList(empty)));
718          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 810 | Line 800 | public class ConcurrentSkipListSubSetTes
800                  assertTrue(changed);
801  
802              assertTrue(q.containsAll(p));
803 <            assertEquals(SIZE-i, q.size());
803 >            assertEquals(SIZE - i, q.size());
804              p.pollFirst();
805          }
806      }
# Line 823 | Line 813 | public class ConcurrentSkipListSubSetTes
813              NavigableSet q = populatedSet(SIZE);
814              NavigableSet p = populatedSet(i);
815              assertTrue(q.removeAll(p));
816 <            assertEquals(SIZE-i, q.size());
816 >            assertEquals(SIZE - i, q.size());
817              for (int j = 0; j < i; ++j) {
818 <                Integer I = (Integer)(p.pollFirst());
819 <                assertFalse(q.contains(I));
818 >                Integer x = (Integer)(p.pollFirst());
819 >                assertFalse(q.contains(x));
820              }
821          }
822      }

Diff Legend

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