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.25 by jsr166, Wed Dec 31 16:44:01 2014 UTC vs.
Revision 1.30 by jsr166, Sat Feb 28 18:10:55 2015 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 – import junit.framework.*;
7   import java.util.Arrays;
8   import java.util.Comparator;
9   import java.util.Iterator;
# Line 12 | Line 11 | import java.util.NavigableSet;
11   import java.util.SortedSet;
12   import java.util.concurrent.ConcurrentSkipListSet;
13  
14 + import junit.framework.Test;
15 + import junit.framework.TestSuite;
16 +
17   public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
18      public static void main(String[] args) {
19          junit.textui.TestRunner.run(suite());
# Line 35 | 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 133 | Line 135 | public class ConcurrentSkipListSubSetTes
135       * add(null) throws NPE
136       */
137      public void testAddNull() {
138 +        NavigableSet q = set0();
139          try {
137 –            NavigableSet q = set0();
140              q.add(null);
141              shouldThrow();
142          } catch (NullPointerException success) {}
# Line 161 | Line 163 | public class ConcurrentSkipListSubSetTes
163       * Add of non-Comparable throws CCE
164       */
165      public void testAddNonComparable() {
166 +        NavigableSet q = set0();
167          try {
165 –            NavigableSet q = set0();
168              q.add(new Object());
169              q.add(new Object());
170              q.add(new Object());
# Line 174 | Line 176 | public class ConcurrentSkipListSubSetTes
176       * addAll(null) throws NPE
177       */
178      public void testAddAll1() {
179 +        NavigableSet q = set0();
180          try {
178 –            NavigableSet q = set0();
181              q.addAll(null);
182              shouldThrow();
183          } catch (NullPointerException success) {}
# Line 185 | Line 187 | public class ConcurrentSkipListSubSetTes
187       * addAll of a collection with null elements throws NPE
188       */
189      public void testAddAll2() {
190 +        NavigableSet q = set0();
191 +        Integer[] ints = new Integer[SIZE];
192          try {
189 –            NavigableSet q = set0();
190 –            Integer[] ints = new Integer[SIZE];
193              q.addAll(Arrays.asList(ints));
194              shouldThrow();
195          } catch (NullPointerException success) {}
# Line 198 | Line 200 | public class ConcurrentSkipListSubSetTes
200       * possibly adding some elements
201       */
202      public void testAddAll3() {
203 +        NavigableSet q = set0();
204 +        Integer[] ints = new Integer[SIZE];
205 +        for (int i = 0; i < SIZE-1; ++i)
206 +            ints[i] = new Integer(i+SIZE);
207          try {
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);
208              q.addAll(Arrays.asList(ints));
209              shouldThrow();
210          } catch (NullPointerException success) {}
# Line 239 | Line 241 | public class ConcurrentSkipListSubSetTes
241       */
242      public void testRemoveElement() {
243          NavigableSet q = populatedSet(SIZE);
244 <        for (int i = 1; i < SIZE; i+=2) {
244 >        for (int i = 1; i < SIZE; i += 2) {
245              assertTrue(q.contains(i));
246              assertTrue(q.remove(i));
247              assertFalse(q.contains(i));
248              assertTrue(q.contains(i-1));
249          }
250 <        for (int i = 0; i < SIZE; i+=2) {
250 >        for (int i = 0; i < SIZE; i += 2) {
251              assertTrue(q.contains(i));
252              assertTrue(q.remove(i));
253              assertFalse(q.contains(i));
# Line 324 | Line 326 | public class ConcurrentSkipListSubSetTes
326              assertTrue(q.removeAll(p));
327              assertEquals(SIZE-i, q.size());
328              for (int j = 0; j < i; ++j) {
329 <                Integer I = (Integer)(p.pollFirst());
330 <                assertFalse(q.contains(I));
329 >                Integer x = (Integer)(p.pollFirst());
330 >                assertFalse(q.contains(x));
331              }
332          }
333      }
# Line 429 | Line 431 | public class ConcurrentSkipListSubSetTes
431       */
432      public void testIterator() {
433          NavigableSet q = populatedSet(SIZE);
432 –        int i = 0;
434          Iterator it = q.iterator();
435 <        while (it.hasNext()) {
435 >        int i;
436 >        for (i = 0; it.hasNext(); i++)
437              assertTrue(q.contains(it.next()));
436 –            ++i;
437 –        }
438          assertEquals(i, SIZE);
439 +        assertIteratorExhausted(it);
440      }
441  
442      /**
443       * iterator of empty set has no elements
444       */
445      public void testEmptyIterator() {
446 <        NavigableSet q = set0();
446 <        int i = 0;
447 <        Iterator it = q.iterator();
448 <        while (it.hasNext()) {
449 <            assertTrue(q.contains(it.next()));
450 <            ++i;
451 <        }
452 <        assertEquals(0, i);
446 >        assertIteratorExhausted(set0().iterator());
447      }
448  
449      /**
# Line 638 | Line 632 | public class ConcurrentSkipListSubSetTes
632       * add(null) throws NPE
633       */
634      public void testDescendingAddNull() {
635 +        NavigableSet q = dset0();
636          try {
642 –            NavigableSet q = dset0();
637              q.add(null);
638              shouldThrow();
639          } catch (NullPointerException success) {}
# Line 666 | Line 660 | public class ConcurrentSkipListSubSetTes
660       * Add of non-Comparable throws CCE
661       */
662      public void testDescendingAddNonComparable() {
663 +        NavigableSet q = dset0();
664          try {
670 –            NavigableSet q = dset0();
665              q.add(new Object());
666              q.add(new Object());
667              q.add(new Object());
# Line 679 | Line 673 | public class ConcurrentSkipListSubSetTes
673       * addAll(null) throws NPE
674       */
675      public void testDescendingAddAll1() {
676 +        NavigableSet q = dset0();
677          try {
683 –            NavigableSet q = dset0();
678              q.addAll(null);
679              shouldThrow();
680          } catch (NullPointerException success) {}
# Line 690 | Line 684 | public class ConcurrentSkipListSubSetTes
684       * addAll of a collection with null elements throws NPE
685       */
686      public void testDescendingAddAll2() {
687 +        NavigableSet q = dset0();
688 +        Integer[] ints = new Integer[SIZE];
689          try {
694 –            NavigableSet q = dset0();
695 –            Integer[] ints = new Integer[SIZE];
690              q.addAll(Arrays.asList(ints));
691              shouldThrow();
692          } catch (NullPointerException success) {}
# Line 703 | Line 697 | public class ConcurrentSkipListSubSetTes
697       * possibly adding some elements
698       */
699      public void testDescendingAddAll3() {
700 +        NavigableSet q = dset0();
701 +        Integer[] ints = new Integer[SIZE];
702 +        for (int i = 0; i < SIZE-1; ++i)
703 +            ints[i] = new Integer(i+SIZE);
704          try {
707 –            NavigableSet q = dset0();
708 –            Integer[] ints = new Integer[SIZE];
709 –            for (int i = 0; i < SIZE-1; ++i)
710 –                ints[i] = new Integer(i+SIZE);
705              q.addAll(Arrays.asList(ints));
706              shouldThrow();
707          } catch (NullPointerException success) {}
# Line 744 | Line 738 | public class ConcurrentSkipListSubSetTes
738       */
739      public void testDescendingRemoveElement() {
740          NavigableSet q = populatedSet(SIZE);
741 <        for (int i = 1; i < SIZE; i+=2) {
741 >        for (int i = 1; i < SIZE; i += 2) {
742              assertTrue(q.remove(new Integer(i)));
743          }
744 <        for (int i = 0; i < SIZE; i+=2) {
744 >        for (int i = 0; i < SIZE; i += 2 ) {
745              assertTrue(q.remove(new Integer(i)));
746              assertFalse(q.remove(new Integer(i+1)));
747          }
# Line 823 | Line 817 | public class ConcurrentSkipListSubSetTes
817              assertTrue(q.removeAll(p));
818              assertEquals(SIZE-i, q.size());
819              for (int j = 0; j < i; ++j) {
820 <                Integer I = (Integer)(p.pollFirst());
821 <                assertFalse(q.contains(I));
820 >                Integer x = (Integer)(p.pollFirst());
821 >                assertFalse(q.contains(x));
822              }
823          }
824      }

Diff Legend

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