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.32 by jsr166, Wed Dec 31 20:09:08 2014 UTC vs.
Revision 1.48 by jsr166, Fri Aug 4 04:59:23 2017 UTC

# Line 21 | Line 21 | import junit.framework.TestSuite;
21  
22   public class ConcurrentSkipListSetTest extends JSR166TestCase {
23      public static void main(String[] args) {
24 <        junit.textui.TestRunner.run(suite());
24 >        main(suite(), args);
25      }
26      public static Test suite() {
27          return new TestSuite(ConcurrentSkipListSetTest.class);
# Line 35 | Line 35 | public class ConcurrentSkipListSetTest e
35  
36      /**
37       * Returns a new set of given size containing consecutive
38 <     * Integers 0 ... n.
38 >     * Integers 0 ... n - 1.
39       */
40 <    private ConcurrentSkipListSet<Integer> populatedSet(int n) {
40 >    private static 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)
47              assertTrue(q.add(new Integer(i)));
# Line 53 | Line 53 | public class ConcurrentSkipListSetTest e
53      /**
54       * Returns a new set of first 5 ints.
55       */
56 <    private ConcurrentSkipListSet set5() {
56 >    private static ConcurrentSkipListSet set5() {
57          ConcurrentSkipListSet q = new ConcurrentSkipListSet();
58          assertTrue(q.isEmpty());
59          q.add(one);
# Line 77 | 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 87 | Line 87 | public class ConcurrentSkipListSetTest e
87       */
88      public void testConstructor4() {
89          try {
90 <            Integer[] ints = new Integer[SIZE];
91 <            ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
90 >            new ConcurrentSkipListSet(Arrays.asList(new Integer[SIZE]));
91              shouldThrow();
92          } catch (NullPointerException success) {}
93      }
# Line 97 | Line 96 | public class ConcurrentSkipListSetTest e
96       * Initializing from Collection with some null elements throws NPE
97       */
98      public void testConstructor5() {
99 +        Integer[] ints = new Integer[SIZE];
100 +        for (int i = 0; i < SIZE - 1; ++i)
101 +            ints[i] = new Integer(i);
102          try {
103 <            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));
103 >            new ConcurrentSkipListSet(Arrays.asList(ints));
104              shouldThrow();
105          } catch (NullPointerException success) {}
106      }
# Line 129 | Line 128 | public class ConcurrentSkipListSetTest e
128          for (int i = 0; i < SIZE; ++i)
129              ints[i] = new Integer(i);
130          q.addAll(Arrays.asList(ints));
131 <        for (int i = SIZE-1; i >= 0; --i)
131 >        for (int i = SIZE - 1; i >= 0; --i)
132              assertEquals(ints[i], q.pollFirst());
133      }
134  
# Line 153 | Line 152 | public class ConcurrentSkipListSetTest e
152      public void testSize() {
153          ConcurrentSkipListSet q = populatedSet(SIZE);
154          for (int i = 0; i < SIZE; ++i) {
155 <            assertEquals(SIZE-i, q.size());
155 >            assertEquals(SIZE - i, q.size());
156              q.pollFirst();
157          }
158          for (int i = 0; i < SIZE; ++i) {
# Line 166 | Line 165 | public class ConcurrentSkipListSetTest e
165       * add(null) throws NPE
166       */
167      public void testAddNull() {
168 +        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
169          try {
170 –            ConcurrentSkipListSet q = new ConcurrentSkipListSet();
170              q.add(null);
171              shouldThrow();
172          } catch (NullPointerException success) {}
# Line 195 | Line 194 | public class ConcurrentSkipListSetTest e
194       * Add of non-Comparable throws CCE
195       */
196      public void testAddNonComparable() {
197 +        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
198          try {
199 –            ConcurrentSkipListSet q = new ConcurrentSkipListSet();
200 –            q.add(new Object());
199              q.add(new Object());
200              q.add(new Object());
201              shouldThrow();
202 <        } catch (ClassCastException success) {}
202 >        } catch (ClassCastException success) {
203 >            assertTrue(q.size() < 2);
204 >            for (int i = 0, size = q.size(); i < size; i++)
205 >                assertSame(Object.class, q.pollFirst().getClass());
206 >            assertNull(q.pollFirst());
207 >            assertTrue(q.isEmpty());
208 >            assertEquals(0, q.size());
209 >        }
210      }
211  
212      /**
213       * addAll(null) throws NPE
214       */
215      public void testAddAll1() {
216 +        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
217          try {
212 –            ConcurrentSkipListSet q = new ConcurrentSkipListSet();
218              q.addAll(null);
219              shouldThrow();
220          } catch (NullPointerException success) {}
# Line 219 | Line 224 | public class ConcurrentSkipListSetTest e
224       * addAll of a collection with null elements throws NPE
225       */
226      public void testAddAll2() {
227 +        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
228 +        Integer[] ints = new Integer[SIZE];
229          try {
223 –            ConcurrentSkipListSet q = new ConcurrentSkipListSet();
224 –            Integer[] ints = new Integer[SIZE];
230              q.addAll(Arrays.asList(ints));
231              shouldThrow();
232          } catch (NullPointerException success) {}
# Line 232 | Line 237 | public class ConcurrentSkipListSetTest e
237       * possibly adding some elements
238       */
239      public void testAddAll3() {
240 +        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
241 +        Integer[] ints = new Integer[SIZE];
242 +        for (int i = 0; i < SIZE - 1; ++i)
243 +            ints[i] = new Integer(i);
244          try {
236 –            ConcurrentSkipListSet q = new ConcurrentSkipListSet();
237 –            Integer[] ints = new Integer[SIZE];
238 –            for (int i = 0; i < SIZE-1; ++i)
239 –                ints[i] = new Integer(i);
245              q.addAll(Arrays.asList(ints));
246              shouldThrow();
247          } catch (NullPointerException success) {}
# Line 249 | Line 254 | public class ConcurrentSkipListSetTest e
254          Integer[] empty = new Integer[0];
255          Integer[] ints = new Integer[SIZE];
256          for (int i = 0; i < SIZE; ++i)
257 <            ints[i] = new Integer(SIZE-1-i);
257 >            ints[i] = new Integer(SIZE - 1 - i);
258          ConcurrentSkipListSet q = new ConcurrentSkipListSet();
259          assertFalse(q.addAll(Arrays.asList(empty)));
260          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 273 | Line 278 | public class ConcurrentSkipListSetTest e
278       */
279      public void testPollLast() {
280          ConcurrentSkipListSet q = populatedSet(SIZE);
281 <        for (int i = SIZE-1; i >= 0; --i) {
281 >        for (int i = SIZE - 1; i >= 0; --i) {
282              assertEquals(i, q.pollLast());
283          }
284          assertNull(q.pollFirst());
# Line 288 | Line 293 | public class ConcurrentSkipListSetTest e
293              assertTrue(q.contains(i));
294              assertTrue(q.remove(i));
295              assertFalse(q.contains(i));
296 <            assertTrue(q.contains(i-1));
296 >            assertTrue(q.contains(i - 1));
297          }
298          for (int i = 0; i < SIZE; i += 2) {
299              assertTrue(q.contains(i));
300              assertTrue(q.remove(i));
301              assertFalse(q.contains(i));
302 <            assertFalse(q.remove(i+1));
303 <            assertFalse(q.contains(i+1));
302 >            assertFalse(q.remove(i + 1));
303 >            assertFalse(q.contains(i + 1));
304          }
305          assertTrue(q.isEmpty());
306      }
# Line 354 | Line 359 | public class ConcurrentSkipListSetTest e
359                  assertTrue(changed);
360  
361              assertTrue(q.containsAll(p));
362 <            assertEquals(SIZE-i, q.size());
362 >            assertEquals(SIZE - i, q.size());
363              p.pollFirst();
364          }
365      }
# Line 367 | Line 372 | public class ConcurrentSkipListSetTest e
372              ConcurrentSkipListSet q = populatedSet(SIZE);
373              ConcurrentSkipListSet p = populatedSet(i);
374              assertTrue(q.removeAll(p));
375 <            assertEquals(SIZE-i, q.size());
375 >            assertEquals(SIZE - i, q.size());
376              for (int j = 0; j < i; ++j) {
377 <                Integer I = (Integer)(p.pollFirst());
378 <                assertFalse(q.contains(I));
377 >                Integer x = (Integer)(p.pollFirst());
378 >                assertFalse(q.contains(x));
379              }
380          }
381      }
# Line 473 | Line 478 | public class ConcurrentSkipListSetTest e
478       */
479      public void testIterator() {
480          ConcurrentSkipListSet q = populatedSet(SIZE);
476 –        int i = 0;
481          Iterator it = q.iterator();
482 <        while (it.hasNext()) {
482 >        int i;
483 >        for (i = 0; it.hasNext(); i++)
484              assertTrue(q.contains(it.next()));
480 –            ++i;
481 –        }
485          assertEquals(i, SIZE);
486 +        assertIteratorExhausted(it);
487      }
488  
489      /**
490       * iterator of empty set has no elements
491       */
492      public void testEmptyIterator() {
493 <        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
494 <        int i = 0;
495 <        Iterator it = q.iterator();
492 <        while (it.hasNext()) {
493 <            assertTrue(q.contains(it.next()));
494 <            ++i;
495 <        }
496 <        assertEquals(0, i);
493 >        NavigableSet s = new ConcurrentSkipListSet();
494 >        assertIteratorExhausted(s.iterator());
495 >        assertIteratorExhausted(s.descendingSet().iterator());
496      }
497  
498      /**
# Line 527 | Line 526 | public class ConcurrentSkipListSetTest e
526      }
527  
528      /**
529 <     * A deserialized serialized set has same elements
529 >     * A cloned set equals original
530 >     */
531 >    public void testClone() {
532 >        ConcurrentSkipListSet x = populatedSet(SIZE);
533 >        ConcurrentSkipListSet y = x.clone();
534 >
535 >        assertNotSame(x, y);
536 >        assertEquals(x.size(), y.size());
537 >        assertEquals(x, y);
538 >        assertEquals(y, x);
539 >        while (!x.isEmpty()) {
540 >            assertFalse(y.isEmpty());
541 >            assertEquals(x.pollFirst(), y.pollFirst());
542 >        }
543 >        assertTrue(y.isEmpty());
544 >    }
545 >
546 >    /**
547 >     * A deserialized/reserialized set equals original
548       */
549      public void testSerialization() throws Exception {
550          NavigableSet x = populatedSet(SIZE);
# Line 699 | Line 716 | public class ConcurrentSkipListSetTest e
716      }
717  
718      static NavigableSet<Integer> newSet(Class cl) throws Exception {
719 <        NavigableSet<Integer> result = (NavigableSet<Integer>) cl.newInstance();
719 >        NavigableSet<Integer> result =
720 >            (NavigableSet<Integer>) cl.getConstructor().newInstance();
721          assertEquals(0, result.size());
722          assertFalse(result.iterator().hasNext());
723          return result;
# Line 732 | Line 750 | public class ConcurrentSkipListSetTest e
750          // Add entries till we're back to original size
751          while (set.size() < size) {
752              int element = min + rnd.nextInt(rangeSize);
753 <            assertTrue(element >= min && element<= max);
753 >            assertTrue(element >= min && element <= max);
754              put(set, element, bs);
755          }
756      }
# Line 758 | Line 776 | public class ConcurrentSkipListSetTest e
776          // Add entries till we're back to original size
777          while (set.size() < size) {
778              int element = min - 5 + rnd.nextInt(rangeSize + 10);
779 <            if (element >= min && element<= max) {
779 >            if (element >= min && element <= max) {
780                  put(set, element, bs);
781              } else {
782                  try {
# Line 982 | Line 1000 | public class ConcurrentSkipListSetTest e
1000      }
1001  
1002      static boolean eq(Integer i, int j) {
1003 <        return i == null ? j == -1 : i == j;
1003 >        return (i == null) ? j == -1 : i == j;
1004      }
1005  
1006   }

Diff Legend

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