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.8 by jsr166, Mon Nov 16 05:30:08 2009 UTC vs.
Revision 1.9 by jsr166, Sat Nov 21 02:07:27 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 556 | Line 556 | public class TreeMapTest extends JSR166T
556      public void testSize() {
557          TreeMap map = map5();
558          TreeMap empty = new TreeMap();
559 <        assertEquals(0, empty.size());
560 <        assertEquals(5, map.size());
559 >        assertEquals(0, empty.size());
560 >        assertEquals(5, map.size());
561      }
562  
563      /**
# Line 795 | Line 795 | public class TreeMapTest extends JSR166T
795       * Submaps of submaps subdivide correctly
796       */
797      public void testRecursiveSubMaps() {
798 <        int mapSize = 1000;
799 <        Class cl = TreeMap.class;
798 >        int mapSize = 1000;
799 >        Class cl = TreeMap.class;
800          NavigableMap<Integer, Integer> map = newMap(cl);
801          bs = new BitSet(mapSize);
802  
# Line 814 | Line 814 | public class TreeMapTest extends JSR166T
814  
815      static NavigableMap<Integer, Integer> newMap(Class cl) {
816          NavigableMap<Integer, Integer> result = null;
817 <        try {
817 >        try {
818              result = (NavigableMap<Integer, Integer>) cl.newInstance();
819 <        } catch (Exception e) {
819 >        } catch (Exception e) {
820              fail();
821 <        }
821 >        }
822          assertEquals(result.size(), 0);
823          assertFalse(result.keySet().iterator().hasNext());
824          return result;

Diff Legend

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