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.5 by dl, Sat Apr 19 18:45:18 2008 UTC vs.
Revision 1.10 by jsr166, Sat Nov 21 10:25:05 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);
# 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();
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 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();
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 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 569 | Line 569 | public class TreeMapTest extends JSR166T
569          for (int i = 1; i <= 5; ++i) {
570              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
571          }
572 <    }        
572 >    }
573  
574      // Exception tests
575  
# Line 581 | Line 581 | public class TreeMapTest extends JSR166T
581              TreeMap c = map5();
582              c.get(null);
583              shouldThrow();
584 <        } catch(NullPointerException e){}
584 >        } catch (NullPointerException e) {}
585      }
586  
587      /**
# Line 592 | Line 592 | public class TreeMapTest extends JSR166T
592              TreeMap c = map5();
593              c.containsKey(null);
594              shouldThrow();
595 <        } catch(NullPointerException e){}
595 >        } catch (NullPointerException e) {}
596      }
597  
598      /**
# Line 604 | Line 604 | public class TreeMapTest extends JSR166T
604              c.put("sadsdf", "asdads");
605              c.remove(null);
606              shouldThrow();
607 <        } catch(NullPointerException e){}
607 >        } catch (NullPointerException e) {}
608      }
609  
610      /**
611       * A deserialized map equals original
612       */
613 <    public void testSerialization() {
613 >    public void testSerialization() throws Exception {
614          TreeMap q = map5();
615  
616 <        try {
617 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
618 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
619 <            out.writeObject(q);
620 <            out.close();
621 <
622 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
623 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
624 <            TreeMap r = (TreeMap)in.readObject();
625 <            assertEquals(q.size(), r.size());
626 <            assertTrue(q.equals(r));
627 <            assertTrue(r.equals(q));
628 <        } catch(Exception e){
629 <            e.printStackTrace();
630 <            unexpectedException();
631 <        }
616 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
617 >        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
618 >        out.writeObject(q);
619 >        out.close();
620 >
621 >        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
622 >        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
623 >        TreeMap r = (TreeMap)in.readObject();
624 >        assertEquals(q.size(), r.size());
625 >        assertTrue(q.equals(r));
626 >        assertTrue(r.equals(q));
627      }
628  
629      /**
# Line 658 | Line 653 | public class TreeMapTest extends JSR166T
653          k = (Integer)(r.next());
654          assertEquals(two, k);
655          assertFalse(r.hasNext());
656 <        
656 >
657          Iterator j = sm.keySet().iterator();
658          j.next();
659          j.remove();
# Line 692 | Line 687 | public class TreeMapTest extends JSR166T
687          k = (Integer)(r.next());
688          assertEquals(two, k);
689          assertFalse(r.hasNext());
690 <        
690 >
691          Iterator j = sm.keySet().iterator();
692          j.next();
693          j.remove();
# Line 795 | Line 790 | public class TreeMapTest extends JSR166T
790       * Submaps of submaps subdivide correctly
791       */
792      public void testRecursiveSubMaps() {
793 <        int mapSize = 1000;
794 <        Class cl = TreeMap.class;
793 >        int mapSize = 1000;
794 >        Class cl = TreeMap.class;
795          NavigableMap<Integer, Integer> map = newMap(cl);
796          bs = new BitSet(mapSize);
797  
# Line 814 | Line 809 | public class TreeMapTest extends JSR166T
809  
810      static NavigableMap<Integer, Integer> newMap(Class cl) {
811          NavigableMap<Integer, Integer> result = null;
812 <        try {
812 >        try {
813              result = (NavigableMap<Integer, Integer>) cl.newInstance();
814 <        } catch(Exception e) {
814 >        } catch (Exception e) {
815              fail();
816 <        }
816 >        }
817          assertEquals(result.size(), 0);
818          assertFalse(result.keySet().iterator().hasNext());
819          return result;
# Line 841 | Line 836 | public class TreeMapTest extends JSR166T
836          }
837  
838          // Remove a bunch of entries with iterator
839 <        for(Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
839 >        for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
840              if (rnd.nextBoolean()) {
841                  bs.clear(it.next());
842                  it.remove();
# Line 866 | Line 861 | public class TreeMapTest extends JSR166T
861          }
862  
863          // Remove a bunch of entries with iterator
864 <        for(Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
864 >        for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
865              if (rnd.nextBoolean()) {
866                  bs.clear(it.next());
867                  it.remove();
# Line 882 | Line 877 | public class TreeMapTest extends JSR166T
877                  try {
878                      map.put(key, 2 * key);
879                      fail();
880 <                } catch(IllegalArgumentException e) {
880 >                } catch (IllegalArgumentException e) {
881                      // expected
882                  }
883              }
# Line 1080 | Line 1075 | public class TreeMapTest extends JSR166T
1075              try {
1076                  map.firstKey();
1077                  fail();
1078 <            } catch(NoSuchElementException e) {
1078 >            } catch (NoSuchElementException e) {
1079                  // expected
1080              }
1081              try {
1082                  map.lastKey();
1083                  fail();
1084 <            } catch(NoSuchElementException e) {
1084 >            } catch (NoSuchElementException e) {
1085                  // expected
1086              }
1087          }
# Line 1102 | Line 1097 | public class TreeMapTest extends JSR166T
1097      static boolean eq(Integer i, int j) {
1098          return i == null ? j == -1 : i == j;
1099      }
1100 <    
1100 >
1101   }

Diff Legend

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