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.19 by jsr166, Thu Apr 14 22:55:08 2011 UTC vs.
Revision 1.35 by jsr166, Sun Sep 29 20:40:48 2019 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
8 < import java.util.*;
9 < import java.util.concurrent.*;
10 < import java.io.*;
7 > import java.util.Arrays;
8 > import java.util.BitSet;
9 > import java.util.Collection;
10 > import java.util.Iterator;
11 > import java.util.Map;
12 > import java.util.NavigableMap;
13 > import java.util.NavigableSet;
14 > import java.util.NoSuchElementException;
15 > import java.util.Random;
16 > import java.util.Set;
17 > import java.util.TreeMap;
18 >
19 > import junit.framework.Test;
20  
21   public class TreeMapTest extends JSR166TestCase {
22      public static void main(String[] args) {
23 <        junit.textui.TestRunner.run(suite());
23 >        main(suite(), args);
24      }
25      public static Test suite() {
26 <        return new TestSuite(TreeMapTest.class);
26 >        class Implementation implements MapImplementation {
27 >            public Class<?> klazz() { return TreeMap.class; }
28 >            public Map emptyMap() { return new TreeMap(); }
29 >            public boolean isConcurrent() { return false; }
30 >            public boolean permitsNullKeys() { return false; }
31 >            public boolean permitsNullValues() { return true; }
32 >            public boolean supportsSetValue() { return true; }
33 >        }
34 >        return newTestSuite(
35 >            TreeMapTest.class,
36 >            MapTest.testSuite(new Implementation()));
37      }
38  
39      /**
40 <     * Create a map from Integers 1-5 to Strings "A"-"E".
40 >     * Returns a new map from Integers 1-5 to Strings "A"-"E".
41       */
42      private static TreeMap map5() {
43          TreeMap map = new TreeMap();
# Line 39 | Line 58 | public class TreeMapTest extends JSR166T
58      public void testClear() {
59          TreeMap map = map5();
60          map.clear();
61 <        assertEquals(map.size(), 0);
61 >        assertEquals(0, map.size());
62      }
63  
64      /**
65 <     *
65 >     * copy constructor creates map equal to source map
66       */
67      public void testConstructFromSorted() {
68          TreeMap map = map5();
# Line 119 | Line 138 | public class TreeMapTest extends JSR166T
138          assertEquals(five, map.lastKey());
139      }
140  
122 –
141      /**
142       * keySet.toArray returns contains all keys
143       */
# Line 176 | Line 194 | public class TreeMapTest extends JSR166T
194              last = k;
195              ++count;
196          }
197 <        assertEquals(count ,5);
197 >        assertEquals(5, count);
198      }
199  
200      /**
# Line 195 | Line 213 | public class TreeMapTest extends JSR166T
213              last = k;
214              ++count;
215          }
216 <        assertEquals(count ,5);
216 >        assertEquals(5, count);
217      }
218  
219      /**
# Line 214 | Line 232 | public class TreeMapTest extends JSR166T
232              last = k;
233              ++count;
234          }
235 <        assertEquals(count, 5);
235 >        assertEquals(5, count);
236      }
237  
238      /**
# Line 233 | Line 251 | public class TreeMapTest extends JSR166T
251              last = k;
252              ++count;
253          }
254 <        assertEquals(count, 5);
254 >        assertEquals(5, count);
255      }
256  
257      /**
# Line 413 | Line 431 | public class TreeMapTest extends JSR166T
431          assertNull(e4);
432      }
433  
416 –
434      /**
435       * lowerKey returns preceding element
436       */
# Line 557 | Line 574 | public class TreeMapTest extends JSR166T
574          TreeMap map = map5();
575          String s = map.toString();
576          for (int i = 1; i <= 5; ++i) {
577 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
577 >            assertTrue(s.contains(String.valueOf(i)));
578          }
579      }
580  
# Line 567 | Line 584 | public class TreeMapTest extends JSR166T
584       * get(null) of nonempty map throws NPE
585       */
586      public void testGet_NullPointerException() {
587 +        TreeMap c = map5();
588          try {
571 –            TreeMap c = map5();
589              c.get(null);
590              shouldThrow();
591          } catch (NullPointerException success) {}
# Line 578 | Line 595 | public class TreeMapTest extends JSR166T
595       * containsKey(null) of nonempty map throws NPE
596       */
597      public void testContainsKey_NullPointerException() {
598 +        TreeMap c = map5();
599          try {
582 –            TreeMap c = map5();
600              c.containsKey(null);
601              shouldThrow();
602          } catch (NullPointerException success) {}
# Line 589 | Line 606 | public class TreeMapTest extends JSR166T
606       * remove(null) throws NPE for nonempty map
607       */
608      public void testRemove1_NullPointerException() {
609 +        TreeMap c = new TreeMap();
610 +        c.put("sadsdf", "asdads");
611          try {
593 –            TreeMap c = new TreeMap();
594 –            c.put("sadsdf", "asdads");
612              c.remove(null);
613              shouldThrow();
614          } catch (NullPointerException success) {}
615      }
616  
617      /**
618 <     * A deserialized map equals original
618 >     * A deserialized/reserialized map equals original
619       */
620      public void testSerialization() throws Exception {
621 <        TreeMap q = map5();
621 >        NavigableMap x = map5();
622 >        NavigableMap y = serialClone(x);
623  
624 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
625 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
626 <        out.writeObject(q);
627 <        out.close();
628 <
611 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
612 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
613 <        TreeMap r = (TreeMap)in.readObject();
614 <        assertEquals(q.size(), r.size());
615 <        assertTrue(q.equals(r));
616 <        assertTrue(r.equals(q));
624 >        assertNotSame(x, y);
625 >        assertEquals(x.size(), y.size());
626 >        assertEquals(x.toString(), y.toString());
627 >        assertEquals(x, y);
628 >        assertEquals(y, x);
629      }
630  
631      /**
# Line 799 | Line 811 | public class TreeMapTest extends JSR166T
811  
812      static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception {
813          NavigableMap<Integer, Integer> result
814 <            = (NavigableMap<Integer, Integer>) cl.newInstance();
815 <        assertEquals(result.size(), 0);
814 >            = (NavigableMap<Integer, Integer>) cl.getConstructor().newInstance();
815 >        assertEquals(0, result.size());
816          assertFalse(result.keySet().iterator().hasNext());
817          return result;
818      }
# Line 832 | Line 844 | public class TreeMapTest extends JSR166T
844          // Add entries till we're back to original size
845          while (map.size() < size) {
846              int key = min + rnd.nextInt(rangeSize);
847 <            assertTrue(key >= min && key<= max);
847 >            assertTrue(key >= min && key <= max);
848              put(map, key);
849          }
850      }
# Line 857 | Line 869 | public class TreeMapTest extends JSR166T
869          // Add entries till we're back to original size
870          while (map.size() < size) {
871              int key = min - 5 + rnd.nextInt(rangeSize + 10);
872 <            if (key >= min && key<= max) {
872 >            if (key >= min && key <= max) {
873                  put(map, key);
874              } else {
875                  try {
# Line 1027 | Line 1039 | public class TreeMapTest extends JSR166T
1039              if (bsContainsI)
1040                  size++;
1041          }
1042 <        assertEquals(map.size(), size);
1042 >        assertEquals(size, map.size());
1043  
1044          // Test contents using contains keySet iterator
1045          int size2 = 0;

Diff Legend

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