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

Comparing jsr166/src/test/tck/ConcurrentSkipListMapTest.java (file contents):
Revision 1.28 by jsr166, Sat Nov 26 05:42:14 2011 UTC vs.
Revision 1.40 by jsr166, Fri Aug 4 03:00:20 2017 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
8 < import java.util.*;
7 > import java.util.ArrayList;
8 > import java.util.Arrays;
9 > import java.util.BitSet;
10 > import java.util.Collection;
11 > import java.util.Iterator;
12 > import java.util.Map;
13 > import java.util.NavigableMap;
14 > import java.util.NavigableSet;
15 > import java.util.NoSuchElementException;
16 > import java.util.Random;
17 > import java.util.Set;
18   import java.util.concurrent.ConcurrentSkipListMap;
19  
20 + import junit.framework.Test;
21 + import junit.framework.TestSuite;
22 +
23   public class ConcurrentSkipListMapTest extends JSR166TestCase {
24      public static void main(String[] args) {
25 <        junit.textui.TestRunner.run(suite());
25 >        main(suite(), args);
26      }
27      public static Test suite() {
28          return new TestSuite(ConcurrentSkipListMapTest.class);
29      }
30  
31      /**
32 <     * Create a map from Integers 1-5 to Strings "A"-"E".
32 >     * Returns a new map from Integers 1-5 to Strings "A"-"E".
33       */
34      private static ConcurrentSkipListMap map5() {
35          ConcurrentSkipListMap map = new ConcurrentSkipListMap();
# Line 42 | Line 54 | public class ConcurrentSkipListMapTest e
54      }
55  
56      /**
57 <     *
57 >     * copy constructor creates map equal to source map
58       */
59      public void testConstructFromSorted() {
60          ConcurrentSkipListMap map = map5();
# Line 682 | Line 694 | public class ConcurrentSkipListMapTest e
694       * get(null) of nonempty map throws NPE
695       */
696      public void testGet_NullPointerException() {
697 +        ConcurrentSkipListMap c = map5();
698          try {
686 –            ConcurrentSkipListMap c = map5();
699              c.get(null);
700              shouldThrow();
701          } catch (NullPointerException success) {}
# Line 693 | Line 705 | public class ConcurrentSkipListMapTest e
705       * containsKey(null) of nonempty map throws NPE
706       */
707      public void testContainsKey_NullPointerException() {
708 +        ConcurrentSkipListMap c = map5();
709          try {
697 –            ConcurrentSkipListMap c = map5();
710              c.containsKey(null);
711              shouldThrow();
712          } catch (NullPointerException success) {}
# Line 704 | Line 716 | public class ConcurrentSkipListMapTest e
716       * containsValue(null) throws NPE
717       */
718      public void testContainsValue_NullPointerException() {
719 +        ConcurrentSkipListMap c = new ConcurrentSkipListMap();
720          try {
708 –            ConcurrentSkipListMap c = new ConcurrentSkipListMap();
721              c.containsValue(null);
722              shouldThrow();
723          } catch (NullPointerException success) {}
# Line 715 | Line 727 | public class ConcurrentSkipListMapTest e
727       * put(null,x) throws NPE
728       */
729      public void testPut1_NullPointerException() {
730 +        ConcurrentSkipListMap c = map5();
731          try {
719 –            ConcurrentSkipListMap c = map5();
732              c.put(null, "whatever");
733              shouldThrow();
734          } catch (NullPointerException success) {}
# Line 726 | Line 738 | public class ConcurrentSkipListMapTest e
738       * putIfAbsent(null, x) throws NPE
739       */
740      public void testPutIfAbsent1_NullPointerException() {
741 +        ConcurrentSkipListMap c = map5();
742          try {
730 –            ConcurrentSkipListMap c = map5();
743              c.putIfAbsent(null, "whatever");
744              shouldThrow();
745          } catch (NullPointerException success) {}
# Line 737 | Line 749 | public class ConcurrentSkipListMapTest e
749       * replace(null, x) throws NPE
750       */
751      public void testReplace_NullPointerException() {
752 +        ConcurrentSkipListMap c = map5();
753          try {
741 –            ConcurrentSkipListMap c = map5();
754              c.replace(null, "whatever");
755              shouldThrow();
756          } catch (NullPointerException success) {}
# Line 748 | Line 760 | public class ConcurrentSkipListMapTest e
760       * replace(null, x, y) throws NPE
761       */
762      public void testReplaceValue_NullPointerException() {
763 +        ConcurrentSkipListMap c = map5();
764          try {
752 –            ConcurrentSkipListMap c = map5();
765              c.replace(null, one, "whatever");
766              shouldThrow();
767          } catch (NullPointerException success) {}
# Line 759 | Line 771 | public class ConcurrentSkipListMapTest e
771       * remove(null) throws NPE
772       */
773      public void testRemove1_NullPointerException() {
774 +        ConcurrentSkipListMap c = new ConcurrentSkipListMap();
775 +        c.put("sadsdf", "asdads");
776          try {
763 –            ConcurrentSkipListMap c = new ConcurrentSkipListMap();
764 –            c.put("sadsdf", "asdads");
777              c.remove(null);
778              shouldThrow();
779          } catch (NullPointerException success) {}
# Line 771 | Line 783 | public class ConcurrentSkipListMapTest e
783       * remove(null, x) throws NPE
784       */
785      public void testRemove2_NullPointerException() {
786 +        ConcurrentSkipListMap c = new ConcurrentSkipListMap();
787 +        c.put("sadsdf", "asdads");
788          try {
775 –            ConcurrentSkipListMap c = new ConcurrentSkipListMap();
776 –            c.put("sadsdf", "asdads");
789              c.remove(null, "whatever");
790              shouldThrow();
791          } catch (NullPointerException success) {}
# Line 789 | Line 801 | public class ConcurrentSkipListMapTest e
801      }
802  
803      /**
804 <     * A deserialized map equals original
804 >     * A cloned map equals original
805 >     */
806 >    public void testClone() {
807 >        ConcurrentSkipListMap x = map5();
808 >        ConcurrentSkipListMap y = x.clone();
809 >
810 >        assertNotSame(x, y);
811 >        assertEquals(x.size(), y.size());
812 >        assertEquals(x.toString(), y.toString());
813 >        assertEquals(x, y);
814 >        assertEquals(y, x);
815 >        y.clear();
816 >        assertTrue(y.isEmpty());
817 >        assertFalse(x.equals(y));
818 >    }
819 >
820 >    /**
821 >     * A deserialized/reserialized map equals original
822       */
823      public void testSerialization() throws Exception {
824          NavigableMap x = map5();
825          NavigableMap y = serialClone(x);
826  
827 <        assertTrue(x != y);
827 >        assertNotSame(x, y);
828          assertEquals(x.size(), y.size());
829          assertEquals(x.toString(), y.toString());
830          assertEquals(x, y);
831          assertEquals(y, x);
832 +        y.clear();
833 +        assertTrue(y.isEmpty());
834 +        assertFalse(x.equals(y));
835      }
836  
837      /**
# Line 985 | Line 1017 | public class ConcurrentSkipListMapTest e
1017  
1018      static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception {
1019          NavigableMap<Integer, Integer> result =
1020 <            (NavigableMap<Integer, Integer>) cl.newInstance();
1020 >            (NavigableMap<Integer, Integer>) cl.getConstructor().newInstance();
1021          assertEquals(0, result.size());
1022          assertFalse(result.keySet().iterator().hasNext());
1023          return result;
# Line 1018 | Line 1050 | public class ConcurrentSkipListMapTest e
1050          // Add entries till we're back to original size
1051          while (map.size() < size) {
1052              int key = min + rnd.nextInt(rangeSize);
1053 <            assertTrue(key >= min && key<= max);
1053 >            assertTrue(key >= min && key <= max);
1054              put(map, key);
1055          }
1056      }
# Line 1043 | Line 1075 | public class ConcurrentSkipListMapTest e
1075          // Add entries till we're back to original size
1076          while (map.size() < size) {
1077              int key = min - 5 + rnd.nextInt(rangeSize + 10);
1078 <            if (key >= min && key<= max) {
1078 >            if (key >= min && key <= max) {
1079                  put(map, key);
1080              } else {
1081                  try {
# Line 1261 | Line 1293 | public class ConcurrentSkipListMapTest e
1293      }
1294  
1295      static boolean eq(Integer i, int j) {
1296 <        return i == null ? j == -1 : i == j;
1296 >        return (i == null) ? j == -1 : i == j;
1297      }
1298  
1299   }

Diff Legend

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