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

Diff Legend

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