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

Comparing jsr166/src/test/tck/TreeMapTest.java (file contents):
Revision 1.4 by dl, Thu Apr 20 20:35:00 2006 UTC vs.
Revision 1.12 by jsr166, Tue Dec 1 06:03:49 2009 UTC

# Line 11 | Line 11 | import java.io.*;
11  
12   public class TreeMapTest 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(TreeMapTest.class);
17 >        return new TestSuite(TreeMapTest.class);
18      }
19  
20      /**
21       * Create a map from Integers 1-5 to Strings "A"-"E".
22       */
23 <    private static TreeMap map5() {  
24 <        TreeMap map = new TreeMap();
23 >    private static TreeMap map5() {
24 >        TreeMap map = new TreeMap();
25          assertTrue(map.isEmpty());
26 <        map.put(one, "A");
27 <        map.put(five, "E");
28 <        map.put(three, "C");
29 <        map.put(two, "B");
30 <        map.put(four, "D");
26 >        map.put(one, "A");
27 >        map.put(five, "E");
28 >        map.put(three, "C");
29 >        map.put(two, "B");
30 >        map.put(four, "D");
31          assertFalse(map.isEmpty());
32          assertEquals(5, map.size());
33 <        return map;
33 >        return map;
34      }
35  
36      /**
# Line 38 | Line 38 | public class TreeMapTest extends JSR166T
38       */
39      public void testClear() {
40          TreeMap map = map5();
41 <        map.clear();
42 <        assertEquals(map.size(), 0);
41 >        map.clear();
42 >        assertEquals(map.size(), 0);
43      }
44  
45      /**
46 <     *  
46 >     *
47       */
48      public void testConstructFromSorted() {
49          TreeMap map = map5();
# Line 59 | Line 59 | public class TreeMapTest extends JSR166T
59          TreeMap map2 = map5();
60          assertEquals(map1, map2);
61          assertEquals(map2, map1);
62 <        map1.clear();
62 >        map1.clear();
63          assertFalse(map1.equals(map2));
64          assertFalse(map2.equals(map1));
65      }
# Line 69 | Line 69 | public class TreeMapTest extends JSR166T
69       */
70      public void testContainsKey() {
71          TreeMap map = map5();
72 <        assertTrue(map.containsKey(one));
72 >        assertTrue(map.containsKey(one));
73          assertFalse(map.containsKey(zero));
74      }
75  
# Line 78 | Line 78 | public class TreeMapTest extends JSR166T
78       */
79      public void testContainsValue() {
80          TreeMap map = map5();
81 <        assertTrue(map.containsValue("A"));
81 >        assertTrue(map.containsValue("A"));
82          assertFalse(map.containsValue("Z"));
83      }
84  
# Line 88 | Line 88 | public class TreeMapTest extends JSR166T
88       */
89      public void testGet() {
90          TreeMap map = map5();
91 <        assertEquals("A", (String)map.get(one));
91 >        assertEquals("A", (String)map.get(one));
92          TreeMap empty = new TreeMap();
93          assertNull(empty.get(one));
94      }
# Line 99 | Line 99 | public class TreeMapTest extends JSR166T
99      public void testIsEmpty() {
100          TreeMap empty = new TreeMap();
101          TreeMap map = map5();
102 <        assertTrue(empty.isEmpty());
102 >        assertTrue(empty.isEmpty());
103          assertFalse(map.isEmpty());
104      }
105  
# Line 108 | Line 108 | public class TreeMapTest extends JSR166T
108       */
109      public void testFirstKey() {
110          TreeMap map = map5();
111 <        assertEquals(one, map.firstKey());
111 >        assertEquals(one, map.firstKey());
112      }
113  
114      /**
# Line 116 | Line 116 | public class TreeMapTest extends JSR166T
116       */
117      public void testLastKey() {
118          TreeMap map = map5();
119 <        assertEquals(five, map.lastKey());
119 >        assertEquals(five, map.lastKey());
120      }
121  
122  
# Line 125 | Line 125 | public class TreeMapTest extends JSR166T
125       */
126      public void testKeySetToArray() {
127          TreeMap map = map5();
128 <        Set s = map.keySet();
128 >        Set s = map.keySet();
129          Object[] ar = s.toArray();
130          assertTrue(s.containsAll(Arrays.asList(ar)));
131 <        assertEquals(5, ar.length);
131 >        assertEquals(5, ar.length);
132          ar[0] = m10;
133          assertFalse(s.containsAll(Arrays.asList(ar)));
134      }
# Line 138 | Line 138 | public class TreeMapTest extends JSR166T
138       */
139      public void testDescendingKeySetToArray() {
140          TreeMap map = map5();
141 <        Set s = map.descendingKeySet();
141 >        Set s = map.descendingKeySet();
142          Object[] ar = s.toArray();
143 <        assertEquals(5, ar.length);
143 >        assertEquals(5, ar.length);
144          assertTrue(s.containsAll(Arrays.asList(ar)));
145          ar[0] = m10;
146          assertFalse(s.containsAll(Arrays.asList(ar)));
# Line 151 | Line 151 | public class TreeMapTest extends JSR166T
151       */
152      public void testKeySet() {
153          TreeMap map = map5();
154 <        Set s = map.keySet();
155 <        assertEquals(5, s.size());
156 <        assertTrue(s.contains(one));
157 <        assertTrue(s.contains(two));
158 <        assertTrue(s.contains(three));
159 <        assertTrue(s.contains(four));
160 <        assertTrue(s.contains(five));
154 >        Set s = map.keySet();
155 >        assertEquals(5, s.size());
156 >        assertTrue(s.contains(one));
157 >        assertTrue(s.contains(two));
158 >        assertTrue(s.contains(three));
159 >        assertTrue(s.contains(four));
160 >        assertTrue(s.contains(five));
161      }
162  
163      /**
# Line 165 | Line 165 | public class TreeMapTest extends JSR166T
165       */
166      public void testKeySetOrder() {
167          TreeMap map = map5();
168 <        Set s = map.keySet();
168 >        Set s = map.keySet();
169          Iterator i = s.iterator();
170          Integer last = (Integer)i.next();
171          assertEquals(last, one);
172 +        int count = 1;
173          while (i.hasNext()) {
174              Integer k = (Integer)i.next();
175              assertTrue(last.compareTo(k) < 0);
176              last = k;
177 +            ++count;
178          }
179 +        assertEquals(count ,5);
180 +    }
181 +
182 +    /**
183 +     * descending iterator of key set is inverse ordered
184 +     */
185 +    public void testKeySetDescendingIteratorOrder() {
186 +        TreeMap map = map5();
187 +        NavigableSet s = map.navigableKeySet();
188 +        Iterator i = s.descendingIterator();
189 +        Integer last = (Integer)i.next();
190 +        assertEquals(last, five);
191 +        int count = 1;
192 +        while (i.hasNext()) {
193 +            Integer k = (Integer)i.next();
194 +            assertTrue(last.compareTo(k) > 0);
195 +            last = k;
196 +            ++count;
197 +        }
198 +        assertEquals(count ,5);
199      }
200  
201      /**
# Line 181 | Line 203 | public class TreeMapTest extends JSR166T
203       */
204      public void testDescendingKeySetOrder() {
205          TreeMap map = map5();
206 <        Set s = map.descendingKeySet();
206 >        Set s = map.descendingKeySet();
207          Iterator i = s.iterator();
208          Integer last = (Integer)i.next();
209          assertEquals(last, five);
210 +        int count = 1;
211          while (i.hasNext()) {
212              Integer k = (Integer)i.next();
213              assertTrue(last.compareTo(k) > 0);
214              last = k;
215 +            ++count;
216          }
217 +        assertEquals(count, 5);
218 +    }
219 +
220 +    /**
221 +     *  descending iterator of descendingKeySet is ordered
222 +     */
223 +    public void testDescendingKeySetDescendingIteratorOrder() {
224 +        TreeMap map = map5();
225 +        NavigableSet s = map.descendingKeySet();
226 +        Iterator i = s.descendingIterator();
227 +        Integer last = (Integer)i.next();
228 +        assertEquals(last, one);
229 +        int count = 1;
230 +        while (i.hasNext()) {
231 +            Integer k = (Integer)i.next();
232 +            assertTrue(last.compareTo(k) < 0);
233 +            last = k;
234 +            ++count;
235 +        }
236 +        assertEquals(count, 5);
237      }
238  
239      /**
# Line 197 | Line 241 | public class TreeMapTest extends JSR166T
241       */
242      public void testValues() {
243          TreeMap map = map5();
244 <        Collection s = map.values();
245 <        assertEquals(5, s.size());
246 <        assertTrue(s.contains("A"));
247 <        assertTrue(s.contains("B"));
248 <        assertTrue(s.contains("C"));
249 <        assertTrue(s.contains("D"));
250 <        assertTrue(s.contains("E"));
244 >        Collection s = map.values();
245 >        assertEquals(5, s.size());
246 >        assertTrue(s.contains("A"));
247 >        assertTrue(s.contains("B"));
248 >        assertTrue(s.contains("C"));
249 >        assertTrue(s.contains("D"));
250 >        assertTrue(s.contains("E"));
251      }
252  
253      /**
# Line 211 | Line 255 | public class TreeMapTest extends JSR166T
255       */
256      public void testEntrySet() {
257          TreeMap map = map5();
258 <        Set s = map.entrySet();
259 <        assertEquals(5, s.size());
258 >        Set s = map.entrySet();
259 >        assertEquals(5, s.size());
260          Iterator it = s.iterator();
261          while (it.hasNext()) {
262              Map.Entry e = (Map.Entry) it.next();
263 <            assertTrue(
263 >            assertTrue(
264                         (e.getKey().equals(one) && e.getValue().equals("A")) ||
265                         (e.getKey().equals(two) && e.getValue().equals("B")) ||
266                         (e.getKey().equals(three) && e.getValue().equals("C")) ||
# Line 230 | Line 274 | public class TreeMapTest extends JSR166T
274       */
275      public void testDescendingEntrySet() {
276          TreeMap map = map5();
277 <        Set s = map.descendingMap().entrySet();
278 <        assertEquals(5, s.size());
277 >        Set s = map.descendingMap().entrySet();
278 >        assertEquals(5, s.size());
279          Iterator it = s.iterator();
280          while (it.hasNext()) {
281              Map.Entry e = (Map.Entry) it.next();
282 <            assertTrue(
282 >            assertTrue(
283                         (e.getKey().equals(one) && e.getValue().equals("A")) ||
284                         (e.getKey().equals(two) && e.getValue().equals("B")) ||
285                         (e.getKey().equals(three) && e.getValue().equals("C")) ||
# Line 249 | Line 293 | public class TreeMapTest extends JSR166T
293       */
294      public void testEntrySetToArray() {
295          TreeMap map = map5();
296 <        Set s = map.entrySet();
296 >        Set s = map.entrySet();
297          Object[] ar = s.toArray();
298          assertEquals(5, ar.length);
299          for (int i = 0; i < 5; ++i) {
# Line 263 | Line 307 | public class TreeMapTest extends JSR166T
307       */
308      public void testDescendingEntrySetToArray() {
309          TreeMap map = map5();
310 <        Set s = map.descendingMap().entrySet();
310 >        Set s = map.descendingMap().entrySet();
311          Object[] ar = s.toArray();
312          assertEquals(5, ar.length);
313          for (int i = 0; i < 5; ++i) {
# Line 278 | Line 322 | public class TreeMapTest extends JSR166T
322      public void testPutAll() {
323          TreeMap empty = new TreeMap();
324          TreeMap map = map5();
325 <        empty.putAll(map);
326 <        assertEquals(5, empty.size());
327 <        assertTrue(empty.containsKey(one));
328 <        assertTrue(empty.containsKey(two));
329 <        assertTrue(empty.containsKey(three));
330 <        assertTrue(empty.containsKey(four));
331 <        assertTrue(empty.containsKey(five));
325 >        empty.putAll(map);
326 >        assertEquals(5, empty.size());
327 >        assertTrue(empty.containsKey(one));
328 >        assertTrue(empty.containsKey(two));
329 >        assertTrue(empty.containsKey(three));
330 >        assertTrue(empty.containsKey(four));
331 >        assertTrue(empty.containsKey(five));
332      }
333  
334      /**
# Line 292 | Line 336 | public class TreeMapTest extends JSR166T
336       */
337      public void testRemove() {
338          TreeMap map = map5();
339 <        map.remove(five);
340 <        assertEquals(4, map.size());
341 <        assertFalse(map.containsKey(five));
339 >        map.remove(five);
340 >        assertEquals(4, map.size());
341 >        assertFalse(map.containsKey(five));
342      }
343  
344      /**
# Line 472 | Line 516 | public class TreeMapTest extends JSR166T
516          try {
517              e.setValue("A");
518              shouldThrow();
519 <        } catch (Exception ok) {
476 <        }
519 >        } catch (UnsupportedOperationException success) {}
520          e = map.pollFirstEntry();
521          assertNull(e);
522      }
# Line 500 | Line 543 | public class TreeMapTest extends JSR166T
543          try {
544              e.setValue("E");
545              shouldThrow();
546 <        } catch (Exception ok) {
504 <        }
546 >        } catch (UnsupportedOperationException success) {}
547          e = map.pollLastEntry();
548          assertNull(e);
549      }
# Line 512 | Line 554 | public class TreeMapTest extends JSR166T
554      public void testSize() {
555          TreeMap map = map5();
556          TreeMap empty = new TreeMap();
557 <        assertEquals(0, empty.size());
558 <        assertEquals(5, map.size());
557 >        assertEquals(0, empty.size());
558 >        assertEquals(5, map.size());
559      }
560  
561      /**
# Line 525 | Line 567 | public class TreeMapTest extends JSR166T
567          for (int i = 1; i <= 5; ++i) {
568              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
569          }
570 <    }        
570 >    }
571  
572      // Exception tests
573  
# Line 537 | Line 579 | public class TreeMapTest extends JSR166T
579              TreeMap c = map5();
580              c.get(null);
581              shouldThrow();
582 <        } catch(NullPointerException e){}
582 >        } catch (NullPointerException success) {}
583      }
584  
585      /**
# Line 548 | Line 590 | public class TreeMapTest extends JSR166T
590              TreeMap c = map5();
591              c.containsKey(null);
592              shouldThrow();
593 <        } catch(NullPointerException e){}
593 >        } catch (NullPointerException success) {}
594      }
595  
596      /**
# Line 560 | Line 602 | public class TreeMapTest extends JSR166T
602              c.put("sadsdf", "asdads");
603              c.remove(null);
604              shouldThrow();
605 <        } catch(NullPointerException e){}
605 >        } catch (NullPointerException success) {}
606      }
607  
608      /**
609       * A deserialized map equals original
610       */
611 <    public void testSerialization() {
611 >    public void testSerialization() throws Exception {
612          TreeMap q = map5();
613  
614 <        try {
615 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
616 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
617 <            out.writeObject(q);
618 <            out.close();
619 <
620 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
621 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
622 <            TreeMap r = (TreeMap)in.readObject();
623 <            assertEquals(q.size(), r.size());
624 <            assertTrue(q.equals(r));
583 <            assertTrue(r.equals(q));
584 <        } catch(Exception e){
585 <            e.printStackTrace();
586 <            unexpectedException();
587 <        }
614 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
615 >        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
616 >        out.writeObject(q);
617 >        out.close();
618 >
619 >        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
620 >        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
621 >        TreeMap r = (TreeMap)in.readObject();
622 >        assertEquals(q.size(), r.size());
623 >        assertTrue(q.equals(r));
624 >        assertTrue(r.equals(q));
625      }
626  
627      /**
# Line 614 | Line 651 | public class TreeMapTest extends JSR166T
651          k = (Integer)(r.next());
652          assertEquals(two, k);
653          assertFalse(r.hasNext());
654 <        
654 >
655          Iterator j = sm.keySet().iterator();
656          j.next();
657          j.remove();
# Line 623 | Line 660 | public class TreeMapTest extends JSR166T
660          assertEquals(1, sm.size());
661          assertEquals(three, sm.firstKey());
662          assertEquals(three, sm.lastKey());
663 <        assertTrue(sm.remove(three) != null);
663 >        assertEquals("C", sm.remove(three));
664          assertTrue(sm.isEmpty());
665          assertEquals(3, map.size());
666      }
# Line 648 | Line 685 | public class TreeMapTest extends JSR166T
685          k = (Integer)(r.next());
686          assertEquals(two, k);
687          assertFalse(r.hasNext());
688 <        
688 >
689          Iterator j = sm.keySet().iterator();
690          j.next();
691          j.remove();
# Line 656 | Line 693 | public class TreeMapTest extends JSR166T
693          assertEquals(4, map.size());
694          assertEquals(0, sm.size());
695          assertTrue(sm.isEmpty());
696 <        assertTrue(sm.remove(three) == null);
696 >        assertSame(sm.remove(three), null);
697          assertEquals(4, map.size());
698      }
699  
# Line 738 | Line 775 | public class TreeMapTest extends JSR166T
775          NavigableMap ssm = sm.tailMap(four, true);
776          assertEquals(four, ssm.firstKey());
777          assertEquals(five, ssm.lastKey());
778 <        assertTrue(ssm.remove(four) != null);
778 >        assertEquals("D", ssm.remove(four));
779          assertEquals(1, ssm.size());
780          assertEquals(3, sm.size());
781          assertEquals(4, map.size());
# Line 750 | Line 787 | public class TreeMapTest extends JSR166T
787      /**
788       * Submaps of submaps subdivide correctly
789       */
790 <    public void testRecursiveSubMaps() {
791 <        int mapSize = 1000;
792 <        Class cl = TreeMap.class;
790 >    public void testRecursiveSubMaps() throws Exception {
791 >        int mapSize = 1000;
792 >        Class cl = TreeMap.class;
793          NavigableMap<Integer, Integer> map = newMap(cl);
794          bs = new BitSet(mapSize);
795  
# Line 768 | Line 805 | public class TreeMapTest extends JSR166T
805                     0, mapSize - 1, true);
806      }
807  
808 <    static NavigableMap<Integer, Integer> newMap(Class cl) {
809 <        NavigableMap<Integer, Integer> result = null;
810 <        try {
774 <            result = (NavigableMap<Integer, Integer>) cl.newInstance();
775 <        } catch(Exception e) {
776 <            fail();
777 <        }
808 >    static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception {
809 >        NavigableMap<Integer, Integer> result
810 >            = (NavigableMap<Integer, Integer>) cl.newInstance();
811          assertEquals(result.size(), 0);
812          assertFalse(result.keySet().iterator().hasNext());
813          return result;
# Line 797 | Line 830 | public class TreeMapTest extends JSR166T
830          }
831  
832          // Remove a bunch of entries with iterator
833 <        for(Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
833 >        for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
834              if (rnd.nextBoolean()) {
835                  bs.clear(it.next());
836                  it.remove();
# Line 822 | Line 855 | public class TreeMapTest extends JSR166T
855          }
856  
857          // Remove a bunch of entries with iterator
858 <        for(Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
858 >        for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
859              if (rnd.nextBoolean()) {
860                  bs.clear(it.next());
861                  it.remove();
# Line 837 | Line 870 | public class TreeMapTest extends JSR166T
870              } else {
871                  try {
872                      map.put(key, 2 * key);
873 <                    fail();
874 <                } catch(IllegalArgumentException e) {
842 <                    // expected
843 <                }
873 >                    shouldThrow();
874 >                } catch (IllegalArgumentException success) {}
875              }
876          }
877      }
# Line 1035 | Line 1066 | public class TreeMapTest extends JSR166T
1066              assertEq(rs.last(),  -1);
1067              try {
1068                  map.firstKey();
1069 <                fail();
1070 <            } catch(NoSuchElementException e) {
1040 <                // expected
1041 <            }
1069 >                shouldThrow();
1070 >            } catch (NoSuchElementException success) {}
1071              try {
1072                  map.lastKey();
1073 <                fail();
1074 <            } catch(NoSuchElementException e) {
1046 <                // expected
1047 <            }
1073 >                shouldThrow();
1074 >            } catch (NoSuchElementException success) {}
1075          }
1076      }
1077  
# Line 1058 | Line 1085 | public class TreeMapTest extends JSR166T
1085      static boolean eq(Integer i, int j) {
1086          return i == null ? j == -1 : i == j;
1087      }
1088 <    
1088 >
1089   }

Diff Legend

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