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

Comparing jsr166/src/test/tck/TreeSetTest.java (file contents):
Revision 1.36 by jsr166, Sat Feb 28 18:18:56 2015 UTC vs.
Revision 1.48 by jsr166, Mon May 28 21:51:44 2018 UTC

# Line 21 | Line 21 | import junit.framework.TestSuite;
21  
22   public class TreeSetTest 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(TreeSetTest.class);
# Line 40 | Line 40 | public class TreeSetTest extends JSR166T
40  
41      /**
42       * Returns a new set of given size containing consecutive
43 <     * Integers 0 ... n.
43 >     * Integers 0 ... n - 1.
44       */
45 <    private TreeSet<Integer> populatedSet(int n) {
46 <        TreeSet<Integer> q = new TreeSet<Integer>();
45 >    private static TreeSet<Integer> populatedSet(int n) {
46 >        TreeSet<Integer> q = new TreeSet<>();
47          assertTrue(q.isEmpty());
48 <        for (int i = n-1; i >= 0; i -= 2)
48 >        for (int i = n - 1; i >= 0; i -= 2)
49              assertTrue(q.add(new Integer(i)));
50          for (int i = (n & 1); i < n; i += 2)
51              assertTrue(q.add(new Integer(i)));
# Line 57 | Line 57 | public class TreeSetTest extends JSR166T
57      /**
58       * Returns a new set of first 5 ints.
59       */
60 <    private TreeSet set5() {
60 >    private static TreeSet set5() {
61          TreeSet q = new TreeSet();
62          assertTrue(q.isEmpty());
63          q.add(one);
# Line 91 | Line 91 | public class TreeSetTest extends JSR166T
91       */
92      public void testConstructor4() {
93          try {
94 <            Integer[] ints = new Integer[SIZE];
95 <            new TreeSet(Arrays.asList(ints));
94 >            new TreeSet(Arrays.asList(new Integer[SIZE]));
95              shouldThrow();
96          } catch (NullPointerException success) {}
97      }
# Line 101 | Line 100 | public class TreeSetTest extends JSR166T
100       * Initializing from Collection with some null elements throws NPE
101       */
102      public void testConstructor5() {
103 +        Integer[] ints = new Integer[SIZE];
104 +        for (int i = 0; i < SIZE - 1; ++i)
105 +            ints[i] = new Integer(i);
106          try {
105 –            Integer[] ints = new Integer[SIZE];
106 –            for (int i = 0; i < SIZE-1; ++i)
107 –                ints[i] = new Integer(i);
107              new TreeSet(Arrays.asList(ints));
108              shouldThrow();
109          } catch (NullPointerException success) {}
# Line 133 | Line 132 | public class TreeSetTest extends JSR166T
132          for (int i = 0; i < SIZE; ++i)
133              ints[i] = new Integer(i);
134          q.addAll(Arrays.asList(ints));
135 <        for (int i = SIZE-1; i >= 0; --i)
135 >        for (int i = SIZE - 1; i >= 0; --i)
136              assertEquals(ints[i], q.pollFirst());
137      }
138  
# Line 157 | Line 156 | public class TreeSetTest extends JSR166T
156      public void testSize() {
157          TreeSet q = populatedSet(SIZE);
158          for (int i = 0; i < SIZE; ++i) {
159 <            assertEquals(SIZE-i, q.size());
159 >            assertEquals(SIZE - i, q.size());
160              q.pollFirst();
161          }
162          for (int i = 0; i < SIZE; ++i) {
# Line 203 | Line 202 | public class TreeSetTest extends JSR166T
202          try {
203              q.add(new Object());
204              q.add(new Object());
206 –            q.add(new Object());
205              shouldThrow();
206          } catch (ClassCastException success) {}
207      }
# Line 238 | Line 236 | public class TreeSetTest extends JSR166T
236      public void testAddAll3() {
237          TreeSet q = new TreeSet();
238          Integer[] ints = new Integer[SIZE];
239 <        for (int i = 0; i < SIZE-1; ++i)
239 >        for (int i = 0; i < SIZE - 1; ++i)
240              ints[i] = new Integer(i);
241          try {
242              q.addAll(Arrays.asList(ints));
# Line 253 | Line 251 | public class TreeSetTest extends JSR166T
251          Integer[] empty = new Integer[0];
252          Integer[] ints = new Integer[SIZE];
253          for (int i = 0; i < SIZE; ++i)
254 <            ints[i] = new Integer(SIZE-1-i);
254 >            ints[i] = new Integer(SIZE - 1 - i);
255          TreeSet q = new TreeSet();
256          assertFalse(q.addAll(Arrays.asList(empty)));
257          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 277 | Line 275 | public class TreeSetTest extends JSR166T
275       */
276      public void testPollLast() {
277          TreeSet q = populatedSet(SIZE);
278 <        for (int i = SIZE-1; i >= 0; --i) {
278 >        for (int i = SIZE - 1; i >= 0; --i) {
279              assertEquals(i, q.pollLast());
280          }
281          assertNull(q.pollFirst());
# Line 292 | Line 290 | public class TreeSetTest extends JSR166T
290              assertTrue(q.contains(i));
291              assertTrue(q.remove(i));
292              assertFalse(q.contains(i));
293 <            assertTrue(q.contains(i-1));
293 >            assertTrue(q.contains(i - 1));
294          }
295          for (int i = 0; i < SIZE; i += 2) {
296              assertTrue(q.contains(i));
297              assertTrue(q.remove(i));
298              assertFalse(q.contains(i));
299 <            assertFalse(q.remove(i+1));
300 <            assertFalse(q.contains(i+1));
299 >            assertFalse(q.remove(i + 1));
300 >            assertFalse(q.contains(i + 1));
301          }
302          assertTrue(q.isEmpty());
303      }
# Line 358 | Line 356 | public class TreeSetTest extends JSR166T
356                  assertTrue(changed);
357  
358              assertTrue(q.containsAll(p));
359 <            assertEquals(SIZE-i, q.size());
359 >            assertEquals(SIZE - i, q.size());
360              p.pollFirst();
361          }
362      }
# Line 371 | Line 369 | public class TreeSetTest extends JSR166T
369              TreeSet q = populatedSet(SIZE);
370              TreeSet p = populatedSet(i);
371              assertTrue(q.removeAll(p));
372 <            assertEquals(SIZE-i, q.size());
372 >            assertEquals(SIZE - i, q.size());
373              for (int j = 0; j < i; ++j) {
374                  Integer x = (Integer)(p.pollFirst());
375                  assertFalse(q.contains(x));
# Line 456 | Line 454 | public class TreeSetTest extends JSR166T
454       */
455      public void testToArray() {
456          TreeSet q = populatedSet(SIZE);
457 <        Object[] o = q.toArray();
458 <        for (int i = 0; i < o.length; i++)
459 <            assertSame(o[i], q.pollFirst());
457 >        Object[] a = q.toArray();
458 >        assertSame(Object[].class, a.getClass());
459 >        for (Object o : a)
460 >            assertSame(o, q.pollFirst());
461 >        assertTrue(q.isEmpty());
462      }
463  
464      /**
# Line 469 | Line 469 | public class TreeSetTest extends JSR166T
469          Integer[] ints = new Integer[SIZE];
470          Integer[] array = q.toArray(ints);
471          assertSame(ints, array);
472 <        for (int i = 0; i < ints.length; i++)
473 <            assertSame(ints[i], q.pollFirst());
472 >        for (Integer o : ints)
473 >            assertSame(o, q.pollFirst());
474 >        assertTrue(q.isEmpty());
475      }
476  
477      /**
# Line 524 | Line 525 | public class TreeSetTest extends JSR166T
525      }
526  
527      /**
528 <     * A deserialized serialized set has same elements
528 >     * A deserialized/reserialized set equals original
529       */
530      public void testSerialization() throws Exception {
531          NavigableSet x = populatedSet(SIZE);
# Line 697 | Line 698 | public class TreeSetTest extends JSR166T
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 905 | Line 907 | public class TreeSetTest extends JSR166T
907                  else if (element > max)
908                      return -1;
909                  int result = bs.nextSetBit(element);
910 <                return result > max ? -1 : result;
910 >                return (result > max) ? -1 : result;
911              }
912              int higherAscending(int element) {
913                  return ceilingAscending(element + 1);
914              }
915              private int firstAscending() {
916                  int result = ceilingAscending(min);
917 <                return result > max ? -1 : result;
917 >                return (result > max) ? -1 : result;
918              }
919              private int lastAscending() {
920                  int result = floorAscending(max);
921 <                return result < min ? -1 : result;
921 >                return (result < min) ? -1 : result;
922              }
923          }
924          ReferenceSet rs = new ReferenceSet();
# Line 977 | Line 979 | public class TreeSetTest extends JSR166T
979      }
980  
981      static boolean eq(Integer i, int j) {
982 <        return i == null ? j == -1 : i == j;
982 >        return (i == null) ? j == -1 : i == j;
983      }
984  
985   }

Diff Legend

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