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.34 by jsr166, Wed Dec 31 21:45:16 2014 UTC vs.
Revision 1.46 by jsr166, Sat Mar 11 18:20:46 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 >                assertTrue(q.pollFirst().getClass() == Object.class);
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 x = (Integer)(p.pollFirst());
378                  assertFalse(q.contains(x));
# 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 699 | Line 698 | public class ConcurrentSkipListSetTest e
698      }
699  
700      static NavigableSet<Integer> newSet(Class cl) throws Exception {
701 <        NavigableSet<Integer> result = (NavigableSet<Integer>) cl.newInstance();
701 >        NavigableSet<Integer> result =
702 >            (NavigableSet<Integer>) cl.getConstructor().newInstance();
703          assertEquals(0, result.size());
704          assertFalse(result.iterator().hasNext());
705          return result;
# Line 982 | Line 982 | public class ConcurrentSkipListSetTest e
982      }
983  
984      static boolean eq(Integer i, int j) {
985 <        return i == null ? j == -1 : i == j;
985 >        return (i == null) ? j == -1 : i == j;
986      }
987  
988   }

Diff Legend

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