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

Comparing jsr166/src/test/tck/TreeSubSetTest.java (file contents):
Revision 1.7 by jsr166, Fri Nov 20 06:47:13 2009 UTC vs.
Revision 1.15 by jsr166, Thu Nov 4 01:04:54 2010 UTC

# Line 11 | Line 11 | import java.io.*;
11  
12   public class TreeSubSetTest 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(TreeSubSetTest.class);
17 >        return new TestSuite(TreeSubSetTest.class);
18      }
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 35 | Line 31 | public class TreeSubSetTest extends JSR1
31          TreeSet q = new TreeSet();
32          assertTrue(q.isEmpty());
33  
34 <        for (int i = n-1; i >= 0; i-=2)
35 <            assertTrue(q.add(new Integer(i)));
36 <        for (int i = (n & 1); i < n; i+=2)
37 <            assertTrue(q.add(new Integer(i)));
34 >        for (int i = n-1; i >= 0; i-=2)
35 >            assertTrue(q.add(new Integer(i)));
36 >        for (int i = (n & 1); i < n; i+=2)
37 >            assertTrue(q.add(new Integer(i)));
38          assertTrue(q.add(new Integer(-n)));
39          assertTrue(q.add(new Integer(n)));
40          NavigableSet s = q.subSet(new Integer(0), true, new Integer(n), false);
41          assertFalse(s.isEmpty());
42 <        assertEquals(n, s.size());
42 >        assertEquals(n, s.size());
43          return s;
44      }
45  
# Line 61 | Line 57 | public class TreeSubSetTest extends JSR1
57          q.add(zero);
58          q.add(seven);
59          NavigableSet s = q.subSet(one, true, seven, false);
60 <        assertEquals(5, s.size());
60 >        assertEquals(5, s.size());
61          return s;
62      }
63  
# Line 74 | Line 70 | public class TreeSubSetTest extends JSR1
70          q.add(m4);
71          q.add(m5);
72          NavigableSet s = q.descendingSet();
73 <        assertEquals(5, s.size());
73 >        assertEquals(5, s.size());
74          return s;
75      }
76  
77      private static NavigableSet set0() {
78 <        TreeSet set = new TreeSet();
78 >        TreeSet set = new TreeSet();
79          assertTrue(set.isEmpty());
80          return set.tailSet(m1, false);
81      }
82  
83      private static NavigableSet dset0() {
84 <        TreeSet set = new TreeSet();
84 >        TreeSet set = new TreeSet();
85          assertTrue(set.isEmpty());
86          return set;
87      }
# Line 104 | Line 100 | public class TreeSubSetTest extends JSR1
100      public void testEmpty() {
101          NavigableSet q = set0();
102          assertTrue(q.isEmpty());
103 <        q.add(new Integer(1));
103 >        assertTrue(q.add(new Integer(1)));
104          assertFalse(q.isEmpty());
105 <        q.add(new Integer(2));
105 >        assertTrue(q.add(new Integer(2)));
106          q.pollFirst();
107          q.pollFirst();
108          assertTrue(q.isEmpty());
# Line 131 | Line 127 | public class TreeSubSetTest extends JSR1
127       * add(null) throws NPE
128       */
129      public void testAddNull() {
130 <        try {
130 >        try {
131              NavigableSet q = set0();
132              q.add(null);
133              shouldThrow();
# Line 179 | Line 175 | public class TreeSubSetTest extends JSR1
175              shouldThrow();
176          } catch (NullPointerException success) {}
177      }
178 +
179      /**
180       * addAll of a collection with null elements throws NPE
181       */
# Line 190 | Line 187 | public class TreeSubSetTest extends JSR1
187              shouldThrow();
188          } catch (NullPointerException success) {}
189      }
190 +
191      /**
192       * addAll of a collection with any null elements throws NPE after
193       * possibly adding some elements
# Line 209 | Line 207 | public class TreeSubSetTest extends JSR1
207       * Set contains all elements of successful addAll
208       */
209      public void testAddAll5() {
210 <        try {
211 <            Integer[] empty = new Integer[0];
212 <            Integer[] ints = new Integer[SIZE];
213 <            for (int i = 0; i < SIZE; ++i)
214 <                ints[i] = new Integer(SIZE-1- i);
215 <            NavigableSet q = set0();
216 <            assertFalse(q.addAll(Arrays.asList(empty)));
217 <            assertTrue(q.addAll(Arrays.asList(ints)));
218 <            for (int i = 0; i < SIZE; ++i)
221 <                assertEquals(new Integer(i), q.pollFirst());
222 <        }
223 <        finally {}
210 >        Integer[] empty = new Integer[0];
211 >        Integer[] ints = new Integer[SIZE];
212 >        for (int i = 0; i < SIZE; ++i)
213 >            ints[i] = new Integer(SIZE-1- i);
214 >        NavigableSet q = set0();
215 >        assertFalse(q.addAll(Arrays.asList(empty)));
216 >        assertTrue(q.addAll(Arrays.asList(ints)));
217 >        for (int i = 0; i < SIZE; ++i)
218 >            assertEquals(new Integer(i), q.pollFirst());
219      }
220  
221      /**
# Line 229 | Line 224 | public class TreeSubSetTest extends JSR1
224      public void testPoll() {
225          NavigableSet q = populatedSet(SIZE);
226          for (int i = 0; i < SIZE; ++i) {
227 <            assertEquals(i, ((Integer)q.pollFirst()).intValue());
227 >            assertEquals(i, q.pollFirst());
228          }
229 <        assertNull(q.pollFirst());
229 >        assertNull(q.pollFirst());
230      }
231  
232      /**
# Line 269 | Line 264 | public class TreeSubSetTest extends JSR1
264          q.clear();
265          assertTrue(q.isEmpty());
266          assertEquals(0, q.size());
267 <        q.add(new Integer(1));
267 >        assertTrue(q.add(new Integer(1)));
268          assertFalse(q.isEmpty());
269          q.clear();
270          assertTrue(q.isEmpty());
# Line 342 | Line 337 | public class TreeSubSetTest extends JSR1
337  
338          Object e4 = q.lower(zero);
339          assertNull(e4);
345 –
340      }
341  
342      /**
# Line 361 | Line 355 | public class TreeSubSetTest extends JSR1
355  
356          Object e4 = q.higher(six);
357          assertNull(e4);
364 –
358      }
359  
360      /**
# Line 380 | Line 373 | public class TreeSubSetTest extends JSR1
373  
374          Object e4 = q.floor(zero);
375          assertNull(e4);
383 –
376      }
377  
378      /**
# Line 399 | Line 391 | public class TreeSubSetTest extends JSR1
391  
392          Object e4 = q.ceiling(six);
393          assertNull(e4);
402 –
394      }
395  
396      /**
397 <     * toArray contains all elements
397 >     * toArray contains all elements in sorted order
398       */
399      public void testToArray() {
400          NavigableSet q = populatedSet(SIZE);
401 <        Object[] o = q.toArray();
402 <        Arrays.sort(o);
403 <        for (int i = 0; i < o.length; i++)
413 <            assertEquals(o[i], q.pollFirst());
401 >        Object[] o = q.toArray();
402 >        for (int i = 0; i < o.length; i++)
403 >            assertSame(o[i], q.pollFirst());
404      }
405  
406      /**
407 <     * toArray(a) contains all elements
407 >     * toArray(a) contains all elements in sorted order
408       */
409      public void testToArray2() {
410          NavigableSet q = populatedSet(SIZE);
411 <        Integer[] ints = new Integer[SIZE];
412 <        ints = (Integer[])q.toArray(ints);
423 <        Arrays.sort(ints);
411 >        Integer[] ints = new Integer[SIZE];
412 >        assertSame(ints, q.toArray(ints));
413          for (int i = 0; i < ints.length; i++)
414 <            assertEquals(ints[i], q.pollFirst());
414 >            assertSame(ints[i], q.pollFirst());
415      }
416  
417      /**
# Line 431 | Line 420 | public class TreeSubSetTest extends JSR1
420      public void testIterator() {
421          NavigableSet q = populatedSet(SIZE);
422          int i = 0;
423 <        Iterator it = q.iterator();
423 >        Iterator it = q.iterator();
424          while (it.hasNext()) {
425              assertTrue(q.contains(it.next()));
426              ++i;
# Line 445 | Line 434 | public class TreeSubSetTest extends JSR1
434      public void testEmptyIterator() {
435          NavigableSet q = set0();
436          int i = 0;
437 <        Iterator it = q.iterator();
437 >        Iterator it = q.iterator();
438          while (it.hasNext()) {
439              assertTrue(q.contains(it.next()));
440              ++i;
# Line 456 | Line 445 | public class TreeSubSetTest extends JSR1
445      /**
446       * iterator.remove removes current element
447       */
448 <    public void testIteratorRemove () {
448 >    public void testIteratorRemove() {
449          final NavigableSet q = set0();
450          q.add(new Integer(2));
451          q.add(new Integer(1));
# Line 467 | Line 456 | public class TreeSubSetTest extends JSR1
456          it.remove();
457  
458          it = q.iterator();
459 <        assertEquals(it.next(), new Integer(2));
460 <        assertEquals(it.next(), new Integer(3));
459 >        assertEquals(it.next(), 2);
460 >        assertEquals(it.next(), 3);
461          assertFalse(it.hasNext());
462      }
463  
# Line 677 | Line 666 | public class TreeSubSetTest extends JSR1
666              shouldThrow();
667          } catch (NullPointerException success) {}
668      }
669 +
670      /**
671       * addAll of a collection with null elements throws NPE
672       */
# Line 688 | Line 678 | public class TreeSubSetTest extends JSR1
678              shouldThrow();
679          } catch (NullPointerException success) {}
680      }
681 +
682      /**
683       * addAll of a collection with any null elements throws NPE after
684       * possibly adding some elements
# Line 724 | Line 715 | public class TreeSubSetTest extends JSR1
715      public void testDescendingPoll() {
716          NavigableSet q = populatedSet(SIZE);
717          for (int i = 0; i < SIZE; ++i) {
718 <            assertEquals(i, ((Integer)q.pollFirst()).intValue());
718 >            assertEquals(i, q.pollFirst());
719          }
720 <        assertNull(q.pollFirst());
720 >        assertNull(q.pollFirst());
721      }
722  
723      /**
# Line 764 | Line 755 | public class TreeSubSetTest extends JSR1
755          q.clear();
756          assertTrue(q.isEmpty());
757          assertEquals(0, q.size());
758 <        q.add(new Integer(1));
758 >        assertTrue(q.add(new Integer(1)));
759          assertFalse(q.isEmpty());
760          q.clear();
761          assertTrue(q.isEmpty());
# Line 837 | Line 828 | public class TreeSubSetTest extends JSR1
828  
829          Object e4 = q.lower(zero);
830          assertNull(e4);
840 –
831      }
832  
833      /**
# Line 856 | Line 846 | public class TreeSubSetTest extends JSR1
846  
847          Object e4 = q.higher(m6);
848          assertNull(e4);
859 –
849      }
850  
851      /**
# Line 875 | Line 864 | public class TreeSubSetTest extends JSR1
864  
865          Object e4 = q.floor(zero);
866          assertNull(e4);
878 –
867      }
868  
869      /**
# Line 894 | Line 882 | public class TreeSubSetTest extends JSR1
882  
883          Object e4 = q.ceiling(m6);
884          assertNull(e4);
897 –
885      }
886  
887      /**
# Line 902 | Line 889 | public class TreeSubSetTest extends JSR1
889       */
890      public void testDescendingToArray() {
891          NavigableSet q = populatedSet(SIZE);
892 <        Object[] o = q.toArray();
892 >        Object[] o = q.toArray();
893          Arrays.sort(o);
894 <        for (int i = 0; i < o.length; i++)
895 <            assertEquals(o[i], q.pollFirst());
894 >        for (int i = 0; i < o.length; i++)
895 >            assertEquals(o[i], q.pollFirst());
896      }
897  
898      /**
# Line 913 | Line 900 | public class TreeSubSetTest extends JSR1
900       */
901      public void testDescendingToArray2() {
902          NavigableSet q = populatedSet(SIZE);
903 <        Integer[] ints = new Integer[SIZE];
904 <        ints = (Integer[])q.toArray(ints);
903 >        Integer[] ints = new Integer[SIZE];
904 >        assertSame(ints, q.toArray(ints));
905          Arrays.sort(ints);
906          for (int i = 0; i < ints.length; i++)
907              assertEquals(ints[i], q.pollFirst());
# Line 926 | Line 913 | public class TreeSubSetTest extends JSR1
913      public void testDescendingIterator() {
914          NavigableSet q = populatedSet(SIZE);
915          int i = 0;
916 <        Iterator it = q.iterator();
916 >        Iterator it = q.iterator();
917          while (it.hasNext()) {
918              assertTrue(q.contains(it.next()));
919              ++i;
# Line 940 | Line 927 | public class TreeSubSetTest extends JSR1
927      public void testDescendingEmptyIterator() {
928          NavigableSet q = dset0();
929          int i = 0;
930 <        Iterator it = q.iterator();
930 >        Iterator it = q.iterator();
931          while (it.hasNext()) {
932              assertTrue(q.contains(it.next()));
933              ++i;
# Line 951 | Line 938 | public class TreeSubSetTest extends JSR1
938      /**
939       * iterator.remove removes current element
940       */
941 <    public void testDescendingIteratorRemove () {
941 >    public void testDescendingIteratorRemove() {
942          final NavigableSet q = dset0();
943          q.add(new Integer(2));
944          q.add(new Integer(1));
# Line 962 | Line 949 | public class TreeSubSetTest extends JSR1
949          it.remove();
950  
951          it = q.iterator();
952 <        assertEquals(it.next(), new Integer(2));
953 <        assertEquals(it.next(), new Integer(3));
952 >        assertEquals(it.next(), 2);
953 >        assertEquals(it.next(), 3);
954          assertFalse(it.hasNext());
955      }
956  

Diff Legend

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