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

Comparing jsr166/src/test/tck/ConcurrentSkipListSetTest.java (file contents):
Revision 1.26 by jsr166, Thu Dec 8 18:09:09 2011 UTC vs.
Revision 1.36 by jsr166, Sun Feb 22 04:34:44 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.BitSet;
9   import java.util.Collection;
# Line 17 | Line 16 | import java.util.Set;
16   import java.util.SortedSet;
17   import java.util.concurrent.ConcurrentSkipListSet;
18  
19 + import junit.framework.Test;
20 + import junit.framework.TestSuite;
21 +
22   public class ConcurrentSkipListSetTest extends JSR166TestCase {
23      public static void main(String[] args) {
24          junit.textui.TestRunner.run(suite());
# Line 32 | Line 34 | public class ConcurrentSkipListSetTest e
34      }
35  
36      /**
37 <     * Create a set of given size containing consecutive
37 >     * Returns a new set of given size containing consecutive
38       * Integers 0 ... n.
39       */
40      private ConcurrentSkipListSet<Integer> populatedSet(int n) {
41          ConcurrentSkipListSet<Integer> q =
42              new ConcurrentSkipListSet<Integer>();
43          assertTrue(q.isEmpty());
44 <        for (int i = n-1; i >= 0; i-=2)
44 >        for (int i = n-1; i >= 0; i -= 2)
45              assertTrue(q.add(new Integer(i)));
46 <        for (int i = (n & 1); i < n; i+=2)
46 >        for (int i = (n & 1); i < n; i += 2)
47              assertTrue(q.add(new Integer(i)));
48          assertFalse(q.isEmpty());
49          assertEquals(n, q.size());
# Line 49 | Line 51 | public class ConcurrentSkipListSetTest e
51      }
52  
53      /**
54 <     * Create set of first 5 ints
54 >     * Returns a new set of first 5 ints.
55       */
56      private ConcurrentSkipListSet set5() {
57          ConcurrentSkipListSet q = new ConcurrentSkipListSet();
# Line 75 | Line 77 | public class ConcurrentSkipListSetTest e
77       */
78      public void testConstructor3() {
79          try {
80 <            ConcurrentSkipListSet q = new ConcurrentSkipListSet((Collection)null);
80 >            new ConcurrentSkipListSet((Collection)null);
81              shouldThrow();
82          } catch (NullPointerException success) {}
83      }
# Line 86 | Line 88 | public class ConcurrentSkipListSetTest e
88      public void testConstructor4() {
89          try {
90              Integer[] ints = new Integer[SIZE];
91 <            ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
91 >            new ConcurrentSkipListSet(Arrays.asList(ints));
92              shouldThrow();
93          } catch (NullPointerException success) {}
94      }
# Line 99 | Line 101 | public class ConcurrentSkipListSetTest e
101              Integer[] ints = new Integer[SIZE];
102              for (int i = 0; i < SIZE-1; ++i)
103                  ints[i] = new Integer(i);
104 <            ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
104 >            new ConcurrentSkipListSet(Arrays.asList(ints));
105              shouldThrow();
106          } catch (NullPointerException success) {}
107      }
# Line 282 | Line 284 | public class ConcurrentSkipListSetTest e
284       */
285      public void testRemoveElement() {
286          ConcurrentSkipListSet q = populatedSet(SIZE);
287 <        for (int i = 1; i < SIZE; i+=2) {
287 >        for (int i = 1; i < SIZE; i += 2) {
288              assertTrue(q.contains(i));
289              assertTrue(q.remove(i));
290              assertFalse(q.contains(i));
291              assertTrue(q.contains(i-1));
292          }
293 <        for (int i = 0; i < SIZE; i+=2) {
293 >        for (int i = 0; i < SIZE; i += 2) {
294              assertTrue(q.contains(i));
295              assertTrue(q.remove(i));
296              assertFalse(q.contains(i));
# Line 367 | Line 369 | public class ConcurrentSkipListSetTest e
369              assertTrue(q.removeAll(p));
370              assertEquals(SIZE-i, q.size());
371              for (int j = 0; j < i; ++j) {
372 <                Integer I = (Integer)(p.pollFirst());
373 <                assertFalse(q.contains(I));
372 >                Integer x = (Integer)(p.pollFirst());
373 >                assertFalse(q.contains(x));
374              }
375          }
376      }
# Line 471 | Line 473 | public class ConcurrentSkipListSetTest e
473       */
474      public void testIterator() {
475          ConcurrentSkipListSet q = populatedSet(SIZE);
474 –        int i = 0;
476          Iterator it = q.iterator();
477 <        while (it.hasNext()) {
477 >        int i;
478 >        for (i = 0; it.hasNext(); i++)
479              assertTrue(q.contains(it.next()));
478 –            ++i;
479 –        }
480          assertEquals(i, SIZE);
481 +        assertIteratorExhausted(it);
482      }
483  
484      /**
485       * iterator of empty set has no elements
486       */
487      public void testEmptyIterator() {
488 <        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
489 <        int i = 0;
490 <        Iterator it = q.iterator();
490 <        while (it.hasNext()) {
491 <            assertTrue(q.contains(it.next()));
492 <            ++i;
493 <        }
494 <        assertEquals(0, i);
488 >        NavigableSet s = new ConcurrentSkipListSet();
489 >        assertIteratorExhausted(s.iterator());
490 >        assertIteratorExhausted(s.descendingSet().iterator());
491      }
492  
493      /**
# Line 531 | Line 527 | public class ConcurrentSkipListSetTest e
527          NavigableSet x = populatedSet(SIZE);
528          NavigableSet y = serialClone(x);
529  
530 <        assertTrue(x != y);
530 >        assertNotSame(x, y);
531          assertEquals(x.size(), y.size());
532          assertEquals(x, y);
533          assertEquals(y, x);
# Line 685 | Line 681 | public class ConcurrentSkipListSetTest e
681                     0, setSize - 1, true, bs);
682      }
683  
684 +    /**
685 +     * addAll is idempotent
686 +     */
687 +    public void testAddAll_idempotent() throws Exception {
688 +        Set x = populatedSet(SIZE);
689 +        Set y = new ConcurrentSkipListSet(x);
690 +        y.addAll(x);
691 +        assertEquals(x, y);
692 +        assertEquals(y, x);
693 +    }
694 +
695      static NavigableSet<Integer> newSet(Class cl) throws Exception {
696          NavigableSet<Integer> result = (NavigableSet<Integer>) cl.newInstance();
697          assertEquals(0, result.size());
# Line 719 | Line 726 | public class ConcurrentSkipListSetTest e
726          // Add entries till we're back to original size
727          while (set.size() < size) {
728              int element = min + rnd.nextInt(rangeSize);
729 <            assertTrue(element >= min && element<= max);
729 >            assertTrue(element >= min && element <= max);
730              put(set, element, bs);
731          }
732      }
# Line 745 | Line 752 | public class ConcurrentSkipListSetTest e
752          // Add entries till we're back to original size
753          while (set.size() < size) {
754              int element = min - 5 + rnd.nextInt(rangeSize + 10);
755 <            if (element >= min && element<= max) {
755 >            if (element >= min && element <= max) {
756                  put(set, element, bs);
757              } else {
758                  try {

Diff Legend

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