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.9 by jsr166, Sat Nov 21 10:25:05 2009 UTC vs.
Revision 1.16 by jsr166, Fri Nov 5 00:17:22 2010 UTC

# Line 11 | Line 11 | import java.io.*;
11  
12   public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
13      public static void main(String[] args) {
14 <        junit.textui.TestRunner.run (suite());
14 >        junit.textui.TestRunner.run(suite());
15      }
16      public static Test suite() {
17          return new TestSuite(ConcurrentSkipListSubSetTest.class);
# Line 19 | Line 19 | public class ConcurrentSkipListSubSetTes
19  
20      static class MyReverseComparator implements Comparator {
21          public int compare(Object x, Object y) {
22 <            int i = ((Integer)x).intValue();
23 <            int j = ((Integer)y).intValue();
24 <            if (i < j) return 1;
25 <            if (i > j) return -1;
26 <            return 0;
22 >            return ((Comparable)y).compareTo(x);
23          }
24      }
25  
# Line 31 | Line 27 | public class ConcurrentSkipListSubSetTes
27       * Create a set of given size containing consecutive
28       * Integers 0 ... n.
29       */
30 <    private NavigableSet populatedSet(int n) {
31 <        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
30 >    private NavigableSet<Integer> populatedSet(int n) {
31 >        ConcurrentSkipListSet<Integer> q =
32 >            new ConcurrentSkipListSet<Integer>();
33          assertTrue(q.isEmpty());
34  
35          for (int i = n-1; i >= 0; i-=2)
# Line 182 | Line 179 | public class ConcurrentSkipListSubSetTes
179              shouldThrow();
180          } catch (NullPointerException success) {}
181      }
182 +
183      /**
184       * addAll of a collection with null elements throws NPE
185       */
# Line 193 | Line 191 | public class ConcurrentSkipListSubSetTes
191              shouldThrow();
192          } catch (NullPointerException success) {}
193      }
194 +
195      /**
196       * addAll of a collection with any null elements throws NPE after
197       * possibly adding some elements
# Line 212 | Line 211 | public class ConcurrentSkipListSubSetTes
211       * Set contains all elements of successful addAll
212       */
213      public void testAddAll5() {
214 <        try {
215 <            Integer[] empty = new Integer[0];
216 <            Integer[] ints = new Integer[SIZE];
217 <            for (int i = 0; i < SIZE; ++i)
218 <                ints[i] = new Integer(SIZE-1- i);
219 <            NavigableSet q = set0();
220 <            assertFalse(q.addAll(Arrays.asList(empty)));
221 <            assertTrue(q.addAll(Arrays.asList(ints)));
222 <            for (int i = 0; i < SIZE; ++i)
224 <                assertEquals(new Integer(i), q.pollFirst());
225 <        }
226 <        finally {}
214 >        Integer[] empty = new Integer[0];
215 >        Integer[] ints = new Integer[SIZE];
216 >        for (int i = 0; i < SIZE; ++i)
217 >            ints[i] = new Integer(SIZE-1- i);
218 >        NavigableSet q = set0();
219 >        assertFalse(q.addAll(Arrays.asList(empty)));
220 >        assertTrue(q.addAll(Arrays.asList(ints)));
221 >        for (int i = 0; i < SIZE; ++i)
222 >            assertEquals(new Integer(i), q.pollFirst());
223      }
224  
225      /**
# Line 232 | Line 228 | public class ConcurrentSkipListSubSetTes
228      public void testPoll() {
229          NavigableSet q = populatedSet(SIZE);
230          for (int i = 0; i < SIZE; ++i) {
231 <            assertEquals(i, ((Integer)q.pollFirst()).intValue());
231 >            assertEquals(i, q.pollFirst());
232          }
233          assertNull(q.pollFirst());
234      }
# Line 345 | Line 341 | public class ConcurrentSkipListSubSetTes
341  
342          Object e4 = q.lower(zero);
343          assertNull(e4);
348 –
344      }
345  
346      /**
# Line 364 | Line 359 | public class ConcurrentSkipListSubSetTes
359  
360          Object e4 = q.higher(six);
361          assertNull(e4);
367 –
362      }
363  
364      /**
# Line 383 | Line 377 | public class ConcurrentSkipListSubSetTes
377  
378          Object e4 = q.floor(zero);
379          assertNull(e4);
386 –
380      }
381  
382      /**
# Line 402 | Line 395 | public class ConcurrentSkipListSubSetTes
395  
396          Object e4 = q.ceiling(six);
397          assertNull(e4);
405 –
398      }
399  
400      /**
401 <     * toArray contains all elements
401 >     * toArray contains all elements in sorted order
402       */
403      public void testToArray() {
404          NavigableSet q = populatedSet(SIZE);
405          Object[] o = q.toArray();
414 –        Arrays.sort(o);
406          for (int i = 0; i < o.length; i++)
407 <            assertEquals(o[i], q.pollFirst());
407 >            assertSame(o[i], q.pollFirst());
408      }
409  
410      /**
411 <     * toArray(a) contains all elements
411 >     * toArray(a) contains all elements in sorted order
412       */
413      public void testToArray2() {
414 <        NavigableSet q = populatedSet(SIZE);
414 >        NavigableSet<Integer> q = populatedSet(SIZE);
415          Integer[] ints = new Integer[SIZE];
416 <        ints = (Integer[])q.toArray(ints);
417 <        Arrays.sort(ints);
416 >        Integer[] array = q.toArray(ints);
417 >        assertSame(ints, array);
418          for (int i = 0; i < ints.length; i++)
419 <            assertEquals(ints[i], q.pollFirst());
419 >            assertSame(ints[i], q.pollFirst());
420      }
421  
422      /**
# Line 459 | Line 450 | public class ConcurrentSkipListSubSetTes
450      /**
451       * iterator.remove removes current element
452       */
453 <    public void testIteratorRemove () {
453 >    public void testIteratorRemove() {
454          final NavigableSet q = set0();
455          q.add(new Integer(2));
456          q.add(new Integer(1));
# Line 691 | Line 682 | public class ConcurrentSkipListSubSetTes
682              shouldThrow();
683          } catch (NullPointerException success) {}
684      }
685 +
686      /**
687       * addAll of a collection with null elements throws NPE
688       */
# Line 702 | Line 694 | public class ConcurrentSkipListSubSetTes
694              shouldThrow();
695          } catch (NullPointerException success) {}
696      }
697 +
698      /**
699       * addAll of a collection with any null elements throws NPE after
700       * possibly adding some elements
# Line 721 | Line 714 | public class ConcurrentSkipListSubSetTes
714       * Set contains all elements of successful addAll
715       */
716      public void testDescendingAddAll5() {
717 <        try {
718 <            Integer[] empty = new Integer[0];
719 <            Integer[] ints = new Integer[SIZE];
720 <            for (int i = 0; i < SIZE; ++i)
721 <                ints[i] = new Integer(SIZE-1- i);
722 <            NavigableSet q = dset0();
723 <            assertFalse(q.addAll(Arrays.asList(empty)));
724 <            assertTrue(q.addAll(Arrays.asList(ints)));
725 <            for (int i = 0; i < SIZE; ++i)
733 <                assertEquals(new Integer(i), q.pollFirst());
734 <        }
735 <        finally {}
717 >        Integer[] empty = new Integer[0];
718 >        Integer[] ints = new Integer[SIZE];
719 >        for (int i = 0; i < SIZE; ++i)
720 >            ints[i] = new Integer(SIZE-1- i);
721 >        NavigableSet q = dset0();
722 >        assertFalse(q.addAll(Arrays.asList(empty)));
723 >        assertTrue(q.addAll(Arrays.asList(ints)));
724 >        for (int i = 0; i < SIZE; ++i)
725 >            assertEquals(new Integer(i), q.pollFirst());
726      }
727  
728      /**
# Line 741 | Line 731 | public class ConcurrentSkipListSubSetTes
731      public void testDescendingPoll() {
732          NavigableSet q = populatedSet(SIZE);
733          for (int i = 0; i < SIZE; ++i) {
734 <            assertEquals(i, ((Integer)q.pollFirst()).intValue());
734 >            assertEquals(i, q.pollFirst());
735          }
736          assertNull(q.pollFirst());
737      }
# Line 854 | Line 844 | public class ConcurrentSkipListSubSetTes
844  
845          Object e4 = q.lower(zero);
846          assertNull(e4);
857 –
847      }
848  
849      /**
# Line 873 | Line 862 | public class ConcurrentSkipListSubSetTes
862  
863          Object e4 = q.higher(m6);
864          assertNull(e4);
876 –
865      }
866  
867      /**
# Line 892 | Line 880 | public class ConcurrentSkipListSubSetTes
880  
881          Object e4 = q.floor(zero);
882          assertNull(e4);
895 –
883      }
884  
885      /**
# Line 911 | Line 898 | public class ConcurrentSkipListSubSetTes
898  
899          Object e4 = q.ceiling(m6);
900          assertNull(e4);
914 –
901      }
902  
903      /**
# Line 931 | Line 917 | public class ConcurrentSkipListSubSetTes
917      public void testDescendingToArray2() {
918          NavigableSet q = populatedSet(SIZE);
919          Integer[] ints = new Integer[SIZE];
920 <        ints = (Integer[])q.toArray(ints);
920 >        assertSame(ints, q.toArray(ints));
921          Arrays.sort(ints);
922          for (int i = 0; i < ints.length; i++)
923              assertEquals(ints[i], q.pollFirst());
# Line 968 | Line 954 | public class ConcurrentSkipListSubSetTes
954      /**
955       * iterator.remove removes current element
956       */
957 <    public void testDescendingIteratorRemove () {
957 >    public void testDescendingIteratorRemove() {
958          final NavigableSet q = dset0();
959          q.add(new Integer(2));
960          q.add(new Integer(1));

Diff Legend

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