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.26 by jsr166, Wed Dec 31 19:05:42 2014 UTC vs.
Revision 1.31 by jsr166, Sat Feb 28 20:13:46 2015 UTC

# Line 37 | Line 37 | public class ConcurrentSkipListSubSetTes
37              new ConcurrentSkipListSet<Integer>();
38          assertTrue(q.isEmpty());
39  
40 <        for (int i = n-1; i >= 0; i-=2)
40 >        for (int i = n-1; i >= 0; i -= 2)
41              assertTrue(q.add(new Integer(i)));
42 <        for (int i = (n & 1); i < n; i+=2)
42 >        for (int i = (n & 1); i < n; i += 2)
43              assertTrue(q.add(new Integer(i)));
44          assertTrue(q.add(new Integer(-n)));
45          assertTrue(q.add(new Integer(n)));
# 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 241 | Line 240 | public class ConcurrentSkipListSubSetTes
240       */
241      public void testRemoveElement() {
242          NavigableSet q = populatedSet(SIZE);
243 <        for (int i = 1; i < SIZE; i+=2) {
243 >        for (int i = 1; i < SIZE; i += 2) {
244              assertTrue(q.contains(i));
245              assertTrue(q.remove(i));
246              assertFalse(q.contains(i));
247              assertTrue(q.contains(i-1));
248          }
249 <        for (int i = 0; i < SIZE; i+=2) {
249 >        for (int i = 0; i < SIZE; i += 2) {
250              assertTrue(q.contains(i));
251              assertTrue(q.remove(i));
252              assertFalse(q.contains(i));
# Line 326 | Line 325 | public class ConcurrentSkipListSubSetTes
325              assertTrue(q.removeAll(p));
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 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 746 | Line 736 | public class ConcurrentSkipListSubSetTes
736       */
737      public void testDescendingRemoveElement() {
738          NavigableSet q = populatedSet(SIZE);
739 <        for (int i = 1; i < SIZE; i+=2) {
739 >        for (int i = 1; i < SIZE; i += 2) {
740              assertTrue(q.remove(new Integer(i)));
741          }
742 <        for (int i = 0; i < SIZE; i+=2) {
742 >        for (int i = 0; i < SIZE; i += 2 ) {
743              assertTrue(q.remove(new Integer(i)));
744              assertFalse(q.remove(new Integer(i+1)));
745          }
# Line 825 | Line 815 | public class ConcurrentSkipListSubSetTes
815              assertTrue(q.removeAll(p));
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