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

Comparing jsr166/src/test/tck/ConcurrentHashMapTest.java (file contents):
Revision 1.19 by jsr166, Sat Nov 21 17:38:05 2009 UTC vs.
Revision 1.35 by jsr166, Sat Jul 20 16:53:40 2013 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
10   import java.util.*;
11 < import java.util.concurrent.*;
12 < import java.util.Enumeration;
13 < import java.io.*;
11 > import java.util.concurrent.ConcurrentHashMap;
12  
13   public class ConcurrentHashMapTest extends JSR166TestCase {
14      public static void main(String[] args) {
15 <        junit.textui.TestRunner.run (suite());
15 >        junit.textui.TestRunner.run(suite());
16      }
17      public static Test suite() {
18          return new TestSuite(ConcurrentHashMapTest.class);
19      }
20  
21      /**
22 <     * Create a map from Integers 1-5 to Strings "A"-"E".
22 >     * Returns a new map from Integers 1-5 to Strings "A"-"E".
23       */
24      private static ConcurrentHashMap map5() {
25          ConcurrentHashMap map = new ConcurrentHashMap(5);
# Line 36 | Line 34 | public class ConcurrentHashMapTest exten
34          return map;
35      }
36  
37 +    /** Re-implement Integer.compare for old java versions */
38 +    static int compare(int x, int y) { return x < y ? -1 : x > y ? 1 : 0; }
39 +
40 +    // classes for testing Comparable fallbacks
41 +    static class BI implements Comparable<BI> {
42 +        private final int value;
43 +        BI(int value) { this.value = value; }
44 +        public int compareTo(BI other) {
45 +            return compare(value, other.value);
46 +        }
47 +        public boolean equals(Object x) {
48 +            return (x instanceof BI) && ((BI)x).value == value;
49 +        }
50 +        public int hashCode() { return 42; }
51 +    }
52 +    static class CI extends BI { CI(int value) { super(value); } }
53 +    static class DI extends BI { DI(int value) { super(value); } }
54 +
55 +    static class BS implements Comparable<BS> {
56 +        private final String value;
57 +        BS(String value) { this.value = value; }
58 +        public int compareTo(BS other) {
59 +            return value.compareTo(other.value);
60 +        }
61 +        public boolean equals(Object x) {
62 +            return (x instanceof BS) && value.equals(((BS)x).value);
63 +        }
64 +        public int hashCode() { return 42; }
65 +    }
66 +
67 +    static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
68 +        implements Comparable<LexicographicList<E>> {
69 +        LexicographicList(Collection<E> c) { super(c); }
70 +        LexicographicList(E e) { super(Collections.singleton(e)); }
71 +        public int compareTo(LexicographicList<E> other) {
72 +            int common = Math.min(size(), other.size());
73 +            int r = 0;
74 +            for (int i = 0; i < common; i++) {
75 +                if ((r = get(i).compareTo(other.get(i))) != 0)
76 +                    break;
77 +            }
78 +            if (r == 0)
79 +                r = compare(size(), other.size());
80 +            return r;
81 +        }
82 +        private static final long serialVersionUID = 0;
83 +    }
84 +
85 +    static class CollidingObject {
86 +        final String value;
87 +        CollidingObject(final String value) { this.value = value; }
88 +        public int hashCode() { return this.value.hashCode() & 1; }
89 +        public boolean equals(final Object obj) {
90 +            return (obj instanceof CollidingObject) && ((CollidingObject)obj).value.equals(value);
91 +        }
92 +    }
93 +
94 +    static class ComparableCollidingObject extends CollidingObject implements Comparable<ComparableCollidingObject> {
95 +        ComparableCollidingObject(final String value) { super(value); }
96 +        public int compareTo(final ComparableCollidingObject o) {
97 +            return value.compareTo(o.value);
98 +        }
99 +    }
100 +
101 +    /**
102 +     * Inserted elements that are subclasses of the same Comparable
103 +     * class are found.
104 +     */
105 +    public void testComparableFamily() {
106 +        ConcurrentHashMap<BI, Boolean> m =
107 +            new ConcurrentHashMap<BI, Boolean>();
108 +        for (int i = 0; i < 1000; i++) {
109 +            assertTrue(m.put(new CI(i), true) == null);
110 +        }
111 +        for (int i = 0; i < 1000; i++) {
112 +            assertTrue(m.containsKey(new CI(i)));
113 +            assertTrue(m.containsKey(new DI(i)));
114 +        }
115 +    }
116 +
117 +    /**
118 +     * Elements of classes with erased generic type parameters based
119 +     * on Comparable can be inserted and found.
120 +     */
121 +    public void testGenericComparable() {
122 +        ConcurrentHashMap<Object, Boolean> m =
123 +            new ConcurrentHashMap<Object, Boolean>();
124 +        for (int i = 0; i < 1000; i++) {
125 +            BI bi = new BI(i);
126 +            BS bs = new BS(String.valueOf(i));
127 +            LexicographicList<BI> bis = new LexicographicList<BI>(bi);
128 +            LexicographicList<BS> bss = new LexicographicList<BS>(bs);
129 +            assertTrue(m.putIfAbsent(bis, true) == null);
130 +            assertTrue(m.containsKey(bis));
131 +            if (m.putIfAbsent(bss, true) == null)
132 +                assertTrue(m.containsKey(bss));
133 +            assertTrue(m.containsKey(bis));
134 +        }
135 +        for (int i = 0; i < 1000; i++) {
136 +            assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
137 +        }
138 +    }
139 +
140 +    /**
141 +     * Elements of non-comparable classes equal to those of classes
142 +     * with erased generic type parameters based on Comparable can be
143 +     * inserted and found.
144 +     */
145 +    public void testGenericComparable2() {
146 +        ConcurrentHashMap<Object, Boolean> m =
147 +            new ConcurrentHashMap<Object, Boolean>();
148 +        for (int i = 0; i < 1000; i++) {
149 +            m.put(new ArrayList(Collections.singleton(new BI(i))), true);
150 +        }
151 +
152 +        for (int i = 0; i < 1000; i++) {
153 +            LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
154 +            assertTrue(m.containsKey(bis));
155 +        }
156 +    }
157 +
158 +    /**
159 +     * Mixtures of instances of comparable and non-comparable classes
160 +     * can be inserted and found.
161 +     */
162 +    public void testMixedComparable() {
163 +        int size = 10000;
164 +        ConcurrentHashMap<Object, Object> map =
165 +            new ConcurrentHashMap<Object, Object>();
166 +        Random rng = new Random(1370014958369218000L);
167 +        for (int i = 0; i < size; i++) {
168 +            Object x;
169 +            switch (rng.nextInt(4)) {
170 +            case 0:
171 +                x = new Object();
172 +                break;
173 +            case 1:
174 +                x = new CollidingObject(Integer.toString(i));
175 +                break;
176 +            default:
177 +                x = new ComparableCollidingObject(Integer.toString(i));
178 +            }
179 +            assertNull(map.put(x, x));
180 +        }
181 +        int count = 0;
182 +        for (Object k : map.keySet()) {
183 +            assertEquals(map.get(k), k);
184 +            ++count;
185 +        }
186 +        assertEquals(count, size);
187 +        assertEquals(map.size(), size);
188 +        for (Object k : map.keySet()) {
189 +            assertEquals(map.put(k, k), k);
190 +        }
191 +    }
192 +
193      /**
194 <     *  clear removes all pairs
194 >     * clear removes all pairs
195       */
196      public void testClear() {
197          ConcurrentHashMap map = map5();
198          map.clear();
199 <        assertEquals(map.size(), 0);
199 >        assertEquals(0, map.size());
200      }
201  
202      /**
203 <     *  Maps with same contents are equal
203 >     * Maps with same contents are equal
204       */
205      public void testEquals() {
206          ConcurrentHashMap map1 = map5();
# Line 59 | Line 213 | public class ConcurrentHashMapTest exten
213      }
214  
215      /**
216 <     *  contains returns true for contained value
216 >     * contains returns true for contained value
217       */
218      public void testContains() {
219          ConcurrentHashMap map = map5();
# Line 68 | Line 222 | public class ConcurrentHashMapTest exten
222      }
223  
224      /**
225 <     *  containsKey returns true for contained key
225 >     * containsKey returns true for contained key
226       */
227      public void testContainsKey() {
228          ConcurrentHashMap map = map5();
# Line 77 | Line 231 | public class ConcurrentHashMapTest exten
231      }
232  
233      /**
234 <     *  containsValue returns true for held values
234 >     * containsValue returns true for held values
235       */
236      public void testContainsValue() {
237          ConcurrentHashMap map = map5();
# Line 86 | Line 240 | public class ConcurrentHashMapTest exten
240      }
241  
242      /**
243 <     *   enumeration returns an enumeration containing the correct
244 <     *   elements
243 >     * enumeration returns an enumeration containing the correct
244 >     * elements
245       */
246      public void testEnumeration() {
247          ConcurrentHashMap map = map5();
# Line 101 | Line 255 | public class ConcurrentHashMapTest exten
255      }
256  
257      /**
258 <     *  get returns the correct element at the given key,
259 <     *  or null if not present
258 >     * get returns the correct element at the given key,
259 >     * or null if not present
260       */
261      public void testGet() {
262          ConcurrentHashMap map = map5();
# Line 112 | Line 266 | public class ConcurrentHashMapTest exten
266      }
267  
268      /**
269 <     *  isEmpty is true of empty map and false for non-empty
269 >     * isEmpty is true of empty map and false for non-empty
270       */
271      public void testIsEmpty() {
272          ConcurrentHashMap empty = new ConcurrentHashMap();
# Line 122 | Line 276 | public class ConcurrentHashMapTest exten
276      }
277  
278      /**
279 <     *   keys returns an enumeration containing all the keys from the map
279 >     * keys returns an enumeration containing all the keys from the map
280       */
281      public void testKeys() {
282          ConcurrentHashMap map = map5();
# Line 136 | Line 290 | public class ConcurrentHashMapTest exten
290      }
291  
292      /**
293 <     *   keySet returns a Set containing all the keys
293 >     * keySet returns a Set containing all the keys
294       */
295      public void testKeySet() {
296          ConcurrentHashMap map = map5();
# Line 150 | Line 304 | public class ConcurrentHashMapTest exten
304      }
305  
306      /**
307 <     *  keySet.toArray returns contains all keys
307 >     * keySet.toArray returns contains all keys
308       */
309      public void testKeySetToArray() {
310          ConcurrentHashMap map = map5();
# Line 163 | Line 317 | public class ConcurrentHashMapTest exten
317      }
318  
319      /**
320 <     *  Values.toArray contains all values
320 >     * Values.toArray contains all values
321       */
322      public void testValuesToArray() {
323          ConcurrentHashMap map = map5();
# Line 179 | Line 333 | public class ConcurrentHashMapTest exten
333      }
334  
335      /**
336 <     *  entrySet.toArray contains all entries
336 >     * entrySet.toArray contains all entries
337       */
338      public void testEntrySetToArray() {
339          ConcurrentHashMap map = map5();
# Line 226 | Line 380 | public class ConcurrentHashMapTest exten
380      }
381  
382      /**
383 <     *   putAll  adds all key-value pairs from the given map
383 >     * putAll adds all key-value pairs from the given map
384       */
385      public void testPutAll() {
386          ConcurrentHashMap empty = new ConcurrentHashMap();
# Line 241 | Line 395 | public class ConcurrentHashMapTest exten
395      }
396  
397      /**
398 <     *   putIfAbsent works when the given key is not present
398 >     * putIfAbsent works when the given key is not present
399       */
400      public void testPutIfAbsent() {
401          ConcurrentHashMap map = map5();
# Line 250 | Line 404 | public class ConcurrentHashMapTest exten
404      }
405  
406      /**
407 <     *   putIfAbsent does not add the pair if the key is already present
407 >     * putIfAbsent does not add the pair if the key is already present
408       */
409      public void testPutIfAbsent2() {
410          ConcurrentHashMap map = map5();
# Line 258 | Line 412 | public class ConcurrentHashMapTest exten
412      }
413  
414      /**
415 <     *   replace fails when the given key is not present
415 >     * replace fails when the given key is not present
416       */
417      public void testReplace() {
418          ConcurrentHashMap map = map5();
# Line 267 | Line 421 | public class ConcurrentHashMapTest exten
421      }
422  
423      /**
424 <     *   replace succeeds if the key is already present
424 >     * replace succeeds if the key is already present
425       */
426      public void testReplace2() {
427          ConcurrentHashMap map = map5();
# Line 275 | Line 429 | public class ConcurrentHashMapTest exten
429          assertEquals("Z", map.get(one));
430      }
431  
278
432      /**
433       * replace value fails when the given key not mapped to expected value
434       */
# Line 296 | Line 449 | public class ConcurrentHashMapTest exten
449          assertEquals("Z", map.get(one));
450      }
451  
299
452      /**
453 <     *   remove removes the correct key-value pair from the map
453 >     * remove removes the correct key-value pair from the map
454       */
455      public void testRemove() {
456          ConcurrentHashMap map = map5();
# Line 318 | Line 470 | public class ConcurrentHashMapTest exten
470          map.remove(four, "A");
471          assertEquals(4, map.size());
472          assertTrue(map.containsKey(four));
321
473      }
474  
475      /**
476 <     *   size returns the correct values
476 >     * size returns the correct values
477       */
478      public void testSize() {
479          ConcurrentHashMap map = map5();
# Line 338 | Line 489 | public class ConcurrentHashMapTest exten
489          ConcurrentHashMap map = map5();
490          String s = map.toString();
491          for (int i = 1; i <= 5; ++i) {
492 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
492 >            assertTrue(s.contains(String.valueOf(i)));
493          }
494      }
495  
# Line 484 | Line 635 | public class ConcurrentHashMapTest exten
635          } catch (NullPointerException success) {}
636      }
637  
487
638      /**
639       * replace(x, null) throws NPE
640       */
# Line 518 | Line 668 | public class ConcurrentHashMapTest exten
668          } catch (NullPointerException success) {}
669      }
670  
521
671      /**
672       * remove(null) throws NPE
673       */
# Line 556 | Line 705 | public class ConcurrentHashMapTest exten
705       * A deserialized map equals original
706       */
707      public void testSerialization() throws Exception {
708 <        ConcurrentHashMap q = map5();
708 >        Map x = map5();
709 >        Map y = serialClone(x);
710  
711 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
712 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
713 <        out.writeObject(q);
714 <        out.close();
565 <
566 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
567 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
568 <        ConcurrentHashMap r = (ConcurrentHashMap)in.readObject();
569 <        assertEquals(q.size(), r.size());
570 <        assertTrue(q.equals(r));
571 <        assertTrue(r.equals(q));
711 >        assertNotSame(x, y);
712 >        assertEquals(x.size(), y.size());
713 >        assertEquals(x, y);
714 >        assertEquals(y, x);
715      }
716  
574
717      /**
718       * SetValue of an EntrySet entry sets value in the map.
719       */
# Line 583 | Line 725 | public class ConcurrentHashMapTest exten
725              map.put(new Integer(i), new Integer(i));
726          assertFalse(map.isEmpty());
727          Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next();
728 <
729 <        // assert that entry1 is not 16
730 <        assertTrue("entry is 16, test not valid",
731 <                   !entry1.getKey().equals(new Integer(16)));
732 <
733 <        // remove 16 (a different key) from map
734 <        // which just happens to cause entry1 to be cloned in map
735 <        map.remove(new Integer(16));
736 <        entry1.setValue("XYZ");
595 <        assertTrue(map.containsValue("XYZ")); // fails
728 >        // Unless it happens to be first (in which case remainder of
729 >        // test is skipped), remove a possibly-colliding key from map
730 >        // which, under some implementations, may cause entry1 to be
731 >        // cloned in map
732 >        if (!entry1.getKey().equals(new Integer(16))) {
733 >            map.remove(new Integer(16));
734 >            entry1.setValue("XYZ");
735 >            assertTrue(map.containsValue("XYZ")); // fails if write-through broken
736 >        }
737      }
738  
739   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines