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.35 by jsr166, Sun Feb 22 04:34:44 2015 UTC vs.
Revision 1.46 by jsr166, Sat Mar 11 18:20:47 2017 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 170 | Line 169 | public class TreeSetTest extends JSR166T
169       * add(null) throws NPE if nonempty
170       */
171      public void testAddNull() {
172 +        TreeSet q = populatedSet(SIZE);
173          try {
174 –            TreeSet q = populatedSet(SIZE);
174              q.add(null);
175              shouldThrow();
176          } catch (NullPointerException success) {}
# Line 199 | Line 198 | public class TreeSetTest extends JSR166T
198       * Add of non-Comparable throws CCE
199       */
200      public void testAddNonComparable() {
201 +        TreeSet q = new TreeSet();
202          try {
203 –            TreeSet q = new TreeSet();
204 –            q.add(new Object());
203              q.add(new Object());
204              q.add(new Object());
205              shouldThrow();
# Line 212 | Line 210 | public class TreeSetTest extends JSR166T
210       * addAll(null) throws NPE
211       */
212      public void testAddAll1() {
213 +        TreeSet q = new TreeSet();
214          try {
216 –            TreeSet q = new TreeSet();
215              q.addAll(null);
216              shouldThrow();
217          } catch (NullPointerException success) {}
# Line 223 | Line 221 | public class TreeSetTest extends JSR166T
221       * addAll of a collection with null elements throws NPE
222       */
223      public void testAddAll2() {
224 +        TreeSet q = new TreeSet();
225 +        Integer[] ints = new Integer[SIZE];
226          try {
227 –            TreeSet q = new TreeSet();
228 –            Integer[] ints = new Integer[SIZE];
227              q.addAll(Arrays.asList(ints));
228              shouldThrow();
229          } catch (NullPointerException success) {}
# Line 236 | Line 234 | public class TreeSetTest extends JSR166T
234       * possibly adding some elements
235       */
236      public void testAddAll3() {
237 +        TreeSet q = new TreeSet();
238 +        Integer[] ints = new Integer[SIZE];
239 +        for (int i = 0; i < SIZE - 1; ++i)
240 +            ints[i] = new Integer(i);
241          try {
240 –            TreeSet q = new TreeSet();
241 –            Integer[] ints = new Integer[SIZE];
242 –            for (int i = 0; i < SIZE-1; ++i)
243 –                ints[i] = new Integer(i);
242              q.addAll(Arrays.asList(ints));
243              shouldThrow();
244          } catch (NullPointerException success) {}
# 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 697 | Line 695 | public class TreeSetTest extends JSR166T
695      }
696  
697      static NavigableSet<Integer> newSet(Class cl) throws Exception {
698 <        NavigableSet<Integer> result = (NavigableSet<Integer>) cl.newInstance();
698 >        NavigableSet<Integer> result =
699 >            (NavigableSet<Integer>) cl.getConstructor().newInstance();
700          assertEquals(0, result.size());
701          assertFalse(result.iterator().hasNext());
702          return result;
# Line 905 | Line 904 | public class TreeSetTest extends JSR166T
904                  else if (element > max)
905                      return -1;
906                  int result = bs.nextSetBit(element);
907 <                return result > max ? -1 : result;
907 >                return (result > max) ? -1 : result;
908              }
909              int higherAscending(int element) {
910                  return ceilingAscending(element + 1);
911              }
912              private int firstAscending() {
913                  int result = ceilingAscending(min);
914 <                return result > max ? -1 : result;
914 >                return (result > max) ? -1 : result;
915              }
916              private int lastAscending() {
917                  int result = floorAscending(max);
918 <                return result < min ? -1 : result;
918 >                return (result < min) ? -1 : result;
919              }
920          }
921          ReferenceSet rs = new ReferenceSet();
# Line 977 | Line 976 | public class TreeSetTest extends JSR166T
976      }
977  
978      static boolean eq(Integer i, int j) {
979 <        return i == null ? j == -1 : i == j;
979 >        return (i == null) ? j == -1 : i == j;
980      }
981  
982   }

Diff Legend

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