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.7 by jsr166, Mon Nov 16 04:57:10 2009 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();
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      /**
# 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);
# Line 184 | Line 184 | public class TreeMapTest extends JSR166T
184       */
185      public void testKeySetDescendingIteratorOrder() {
186          TreeMap map = map5();
187 <        NavigableSet s = map.navigableKeySet();
187 >        NavigableSet s = map.navigableKeySet();
188          Iterator i = s.descendingIterator();
189          Integer last = (Integer)i.next();
190          assertEquals(last, five);
# Line 203 | 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);
# Line 222 | Line 222 | public class TreeMapTest extends JSR166T
222       */
223      public void testDescendingKeySetDescendingIteratorOrder() {
224          TreeMap map = map5();
225 <        NavigableSet s = map.descendingKeySet();
225 >        NavigableSet s = map.descendingKeySet();
226          Iterator i = s.descendingIterator();
227          Integer last = (Integer)i.next();
228          assertEquals(last, one);
# Line 241 | 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 255 | 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();
# Line 274 | 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();
# Line 293 | 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 307 | 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 322 | 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 336 | 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 516 | Line 516 | public class TreeMapTest extends JSR166T
516          try {
517              e.setValue("A");
518              shouldThrow();
519 <        } catch (Exception ok) {
520 <        }
519 >        } catch (UnsupportedOperationException success) {}
520          e = map.pollFirstEntry();
521          assertNull(e);
522      }
# Line 544 | Line 543 | public class TreeMapTest extends JSR166T
543          try {
544              e.setValue("E");
545              shouldThrow();
546 <        } catch (Exception ok) {
548 <        }
546 >        } catch (UnsupportedOperationException success) {}
547          e = map.pollLastEntry();
548          assertNull(e);
549      }
# Line 556 | 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 581 | 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 592 | 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 604 | 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));
627 <            assertTrue(r.equals(q));
628 <        } catch (Exception e){
629 <            e.printStackTrace();
630 <            unexpectedException();
631 <        }
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 667 | 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 700 | 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 782 | 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 794 | 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 812 | 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 {
818 <            result = (NavigableMap<Integer, Integer>) cl.newInstance();
819 <        } catch (Exception e) {
820 <            fail();
821 <        }
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 881 | Line 870 | public class TreeMapTest extends JSR166T
870              } else {
871                  try {
872                      map.put(key, 2 * key);
873 <                    fail();
874 <                } catch (IllegalArgumentException e) {
886 <                    // expected
887 <                }
873 >                    shouldThrow();
874 >                } catch (IllegalArgumentException success) {}
875              }
876          }
877      }
# Line 1079 | Line 1066 | public class TreeMapTest extends JSR166T
1066              assertEq(rs.last(),  -1);
1067              try {
1068                  map.firstKey();
1069 <                fail();
1070 <            } catch (NoSuchElementException e) {
1084 <                // expected
1085 <            }
1069 >                shouldThrow();
1070 >            } catch (NoSuchElementException success) {}
1071              try {
1072                  map.lastKey();
1073 <                fail();
1074 <            } catch (NoSuchElementException e) {
1090 <                // expected
1091 <            }
1073 >                shouldThrow();
1074 >            } catch (NoSuchElementException success) {}
1075          }
1076      }
1077  

Diff Legend

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