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.24 by jsr166, Fri May 27 19:21:27 2011 UTC vs.
Revision 1.42 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.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  
22   public class ConcurrentSkipListMapTest extends JSR166TestCase {
23      public static void main(String[] args) {
24 <        junit.textui.TestRunner.run(suite());
24 >        main(suite(), args);
25      }
26      public static Test suite() {
27 <        return new TestSuite(ConcurrentSkipListMapTest.class);
27 >        class Implementation implements MapImplementation {
28 >            public Class<?> klazz() { return ConcurrentSkipListMap.class; }
29 >            public Map emptyMap() { return new ConcurrentSkipListMap(); }
30 >            public boolean isConcurrent() { return true; }
31 >            public boolean remappingFunctionCalledAtMostOnce() { return false; };
32 >            public boolean permitsNullKeys() { return false; }
33 >            public boolean permitsNullValues() { return false; }
34 >            public boolean supportsSetValue() { return false; }
35 >        }
36 >        return newTestSuite(
37 >            ConcurrentSkipListMapTest.class,
38 >            MapTest.testSuite(new Implementation()));
39      }
40  
41      /**
42 <     * Create a map from Integers 1-5 to Strings "A"-"E".
42 >     * Returns a new map from Integers 1-5 to Strings "A"-"E".
43       */
44      private static ConcurrentSkipListMap map5() {
45          ConcurrentSkipListMap map = new ConcurrentSkipListMap();
# Line 39 | Line 60 | public class ConcurrentSkipListMapTest e
60      public void testClear() {
61          ConcurrentSkipListMap map = map5();
62          map.clear();
63 <        assertEquals(map.size(), 0);
63 >        assertEquals(0, map.size());
64      }
65  
66      /**
67 <     *
67 >     * copy constructor creates map equal to source map
68       */
69      public void testConstructFromSorted() {
70          ConcurrentSkipListMap map = map5();
# Line 175 | Line 196 | public class ConcurrentSkipListMapTest e
196              last = k;
197              ++count;
198          }
199 <        assertEquals(count ,5);
199 >        assertEquals(5, count);
200      }
201  
202      /**
# Line 194 | Line 215 | public class ConcurrentSkipListMapTest e
215              last = k;
216              ++count;
217          }
218 <        assertEquals(count ,5);
218 >        assertEquals(5, count);
219      }
220  
221      /**
# Line 213 | Line 234 | public class ConcurrentSkipListMapTest e
234              last = k;
235              ++count;
236          }
237 <        assertEquals(count, 5);
237 >        assertEquals(5, count);
238      }
239  
240      /**
# Line 232 | Line 253 | public class ConcurrentSkipListMapTest e
253              last = k;
254              ++count;
255          }
256 <        assertEquals(count, 5);
256 >        assertEquals(5, count);
257      }
258  
259      /**
# Line 502 | Line 523 | public class ConcurrentSkipListMapTest e
523       * lowerEntry, higherEntry, ceilingEntry, and floorEntry return
524       * immutable entries
525       */
526 <    public void testEntryImmutablity() {
526 >    public void testEntryImmutability() {
527          ConcurrentSkipListMap map = map5();
528          Map.Entry e = map.lowerEntry(three);
529          assertEquals(two, e.getKey());
# Line 530 | Line 551 | public class ConcurrentSkipListMapTest e
551          } catch (UnsupportedOperationException success) {}
552      }
553  
533 –
554      /**
555       * lowerKey returns preceding element
556       */
# Line 684 | Line 704 | public class ConcurrentSkipListMapTest e
704       * get(null) of nonempty map throws NPE
705       */
706      public void testGet_NullPointerException() {
707 +        ConcurrentSkipListMap c = map5();
708          try {
688 –            ConcurrentSkipListMap c = map5();
709              c.get(null);
710              shouldThrow();
711          } catch (NullPointerException success) {}
# Line 695 | Line 715 | public class ConcurrentSkipListMapTest e
715       * containsKey(null) of nonempty map throws NPE
716       */
717      public void testContainsKey_NullPointerException() {
718 +        ConcurrentSkipListMap c = map5();
719          try {
699 –            ConcurrentSkipListMap c = map5();
720              c.containsKey(null);
721              shouldThrow();
722          } catch (NullPointerException success) {}
# Line 706 | Line 726 | public class ConcurrentSkipListMapTest e
726       * containsValue(null) throws NPE
727       */
728      public void testContainsValue_NullPointerException() {
729 +        ConcurrentSkipListMap c = new ConcurrentSkipListMap();
730          try {
710 –            ConcurrentSkipListMap c = new ConcurrentSkipListMap();
731              c.containsValue(null);
732              shouldThrow();
733          } catch (NullPointerException success) {}
# Line 717 | Line 737 | public class ConcurrentSkipListMapTest e
737       * put(null,x) throws NPE
738       */
739      public void testPut1_NullPointerException() {
740 +        ConcurrentSkipListMap c = map5();
741          try {
721 –            ConcurrentSkipListMap c = map5();
742              c.put(null, "whatever");
743              shouldThrow();
744          } catch (NullPointerException success) {}
# Line 728 | Line 748 | public class ConcurrentSkipListMapTest e
748       * putIfAbsent(null, x) throws NPE
749       */
750      public void testPutIfAbsent1_NullPointerException() {
751 +        ConcurrentSkipListMap c = map5();
752          try {
732 –            ConcurrentSkipListMap c = map5();
753              c.putIfAbsent(null, "whatever");
754              shouldThrow();
755          } catch (NullPointerException success) {}
# Line 739 | Line 759 | public class ConcurrentSkipListMapTest e
759       * replace(null, x) throws NPE
760       */
761      public void testReplace_NullPointerException() {
762 +        ConcurrentSkipListMap c = map5();
763          try {
743 –            ConcurrentSkipListMap c = map5();
764              c.replace(null, "whatever");
765              shouldThrow();
766          } catch (NullPointerException success) {}
# Line 750 | Line 770 | public class ConcurrentSkipListMapTest e
770       * replace(null, x, y) throws NPE
771       */
772      public void testReplaceValue_NullPointerException() {
773 +        ConcurrentSkipListMap c = map5();
774          try {
754 –            ConcurrentSkipListMap c = map5();
775              c.replace(null, one, "whatever");
776              shouldThrow();
777          } catch (NullPointerException success) {}
# Line 761 | Line 781 | public class ConcurrentSkipListMapTest e
781       * remove(null) throws NPE
782       */
783      public void testRemove1_NullPointerException() {
784 +        ConcurrentSkipListMap c = new ConcurrentSkipListMap();
785 +        c.put("sadsdf", "asdads");
786          try {
765 –            ConcurrentSkipListMap c = new ConcurrentSkipListMap();
766 –            c.put("sadsdf", "asdads");
787              c.remove(null);
788              shouldThrow();
789          } catch (NullPointerException success) {}
# Line 773 | Line 793 | public class ConcurrentSkipListMapTest e
793       * remove(null, x) throws NPE
794       */
795      public void testRemove2_NullPointerException() {
796 +        ConcurrentSkipListMap c = new ConcurrentSkipListMap();
797 +        c.put("sadsdf", "asdads");
798          try {
777 –            ConcurrentSkipListMap c = new ConcurrentSkipListMap();
778 –            c.put("sadsdf", "asdads");
799              c.remove(null, "whatever");
800              shouldThrow();
801          } catch (NullPointerException success) {}
# Line 791 | Line 811 | public class ConcurrentSkipListMapTest e
811      }
812  
813      /**
814 <     * A deserialized map equals original
814 >     * A cloned map equals original
815 >     */
816 >    public void testClone() {
817 >        ConcurrentSkipListMap x = map5();
818 >        ConcurrentSkipListMap y = x.clone();
819 >
820 >        assertNotSame(x, y);
821 >        assertEquals(x.size(), y.size());
822 >        assertEquals(x.toString(), y.toString());
823 >        assertEquals(x, y);
824 >        assertEquals(y, x);
825 >        y.clear();
826 >        assertTrue(y.isEmpty());
827 >        assertFalse(x.equals(y));
828 >    }
829 >
830 >    /**
831 >     * A deserialized/reserialized map equals original
832       */
833      public void testSerialization() throws Exception {
834 <        ConcurrentSkipListMap q = map5();
834 >        NavigableMap x = map5();
835 >        NavigableMap y = serialClone(x);
836  
837 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
838 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
839 <        out.writeObject(q);
840 <        out.close();
841 <
842 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
843 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
844 <        ConcurrentSkipListMap r = (ConcurrentSkipListMap)in.readObject();
807 <        assertEquals(q.size(), r.size());
808 <        assertTrue(q.equals(r));
809 <        assertTrue(r.equals(q));
837 >        assertNotSame(x, y);
838 >        assertEquals(x.size(), y.size());
839 >        assertEquals(x.toString(), y.toString());
840 >        assertEquals(x, y);
841 >        assertEquals(y, x);
842 >        y.clear();
843 >        assertTrue(y.isEmpty());
844 >        assertFalse(x.equals(y));
845      }
846  
847      /**
# Line 992 | Line 1027 | public class ConcurrentSkipListMapTest e
1027  
1028      static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception {
1029          NavigableMap<Integer, Integer> result =
1030 <            (NavigableMap<Integer, Integer>) cl.newInstance();
1031 <        assertEquals(result.size(), 0);
1030 >            (NavigableMap<Integer, Integer>) cl.getConstructor().newInstance();
1031 >        assertEquals(0, result.size());
1032          assertFalse(result.keySet().iterator().hasNext());
1033          return result;
1034      }
# Line 1025 | Line 1060 | public class ConcurrentSkipListMapTest e
1060          // Add entries till we're back to original size
1061          while (map.size() < size) {
1062              int key = min + rnd.nextInt(rangeSize);
1063 <            assertTrue(key >= min && key<= max);
1063 >            assertTrue(key >= min && key <= max);
1064              put(map, key);
1065          }
1066      }
# Line 1050 | Line 1085 | public class ConcurrentSkipListMapTest e
1085          // Add entries till we're back to original size
1086          while (map.size() < size) {
1087              int key = min - 5 + rnd.nextInt(rangeSize + 10);
1088 <            if (key >= min && key<= max) {
1088 >            if (key >= min && key <= max) {
1089                  put(map, key);
1090              } else {
1091                  try {
# Line 1220 | Line 1255 | public class ConcurrentSkipListMapTest e
1255              if (bsContainsI)
1256                  size++;
1257          }
1258 <        assertEquals(map.size(), size);
1258 >        assertEquals(size, map.size());
1259  
1260          // Test contents using contains keySet iterator
1261          int size2 = 0;
# Line 1268 | Line 1303 | public class ConcurrentSkipListMapTest e
1303      }
1304  
1305      static boolean eq(Integer i, int j) {
1306 <        return i == null ? j == -1 : i == j;
1306 >        return (i == null) ? j == -1 : i == j;
1307      }
1308  
1309   }

Diff Legend

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