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.27 by jsr166, Tue Feb 21 01:54:03 2012 UTC vs.
Revision 1.45 by jsr166, Sat Apr 25 04:55:30 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.*;
9 > import java.util.ArrayList;
10 > import java.util.Arrays;
11 > import java.util.Collection;
12 > import java.util.Collections;
13 > import java.util.Enumeration;
14 > import java.util.Iterator;
15 > import java.util.Map;
16 > import java.util.Random;
17 > import java.util.Set;
18   import java.util.concurrent.ConcurrentHashMap;
19  
20 + import junit.framework.Test;
21 + import junit.framework.TestSuite;
22 +
23   public class ConcurrentHashMapTest 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(ConcurrentHashMapTest.class);
29      }
30  
31      /**
32 <     * Creates 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 ConcurrentHashMap map5() {
35 <        ConcurrentHashMap map = new ConcurrentHashMap(5);
34 >    private static ConcurrentHashMap<Integer, String> map5() {
35 >        ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5);
36          assertTrue(map.isEmpty());
37          map.put(one, "A");
38          map.put(two, "B");
# Line 34 | Line 44 | public class ConcurrentHashMapTest exten
44          return map;
45      }
46  
47 +    /** Re-implement Integer.compare for old java versions */
48 +    static int compare(int x, int y) { return x < y ? -1 : x > y ? 1 : 0; }
49 +
50 +    // classes for testing Comparable fallbacks
51 +    static class BI implements Comparable<BI> {
52 +        private final int value;
53 +        BI(int value) { this.value = value; }
54 +        public int compareTo(BI other) {
55 +            return compare(value, other.value);
56 +        }
57 +        public boolean equals(Object x) {
58 +            return (x instanceof BI) && ((BI)x).value == value;
59 +        }
60 +        public int hashCode() { return 42; }
61 +    }
62 +    static class CI extends BI { CI(int value) { super(value); } }
63 +    static class DI extends BI { DI(int value) { super(value); } }
64 +
65 +    static class BS implements Comparable<BS> {
66 +        private final String value;
67 +        BS(String value) { this.value = value; }
68 +        public int compareTo(BS other) {
69 +            return value.compareTo(other.value);
70 +        }
71 +        public boolean equals(Object x) {
72 +            return (x instanceof BS) && value.equals(((BS)x).value);
73 +        }
74 +        public int hashCode() { return 42; }
75 +    }
76 +
77 +    static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
78 +        implements Comparable<LexicographicList<E>> {
79 +        LexicographicList(Collection<E> c) { super(c); }
80 +        LexicographicList(E e) { super(Collections.singleton(e)); }
81 +        public int compareTo(LexicographicList<E> other) {
82 +            int common = Math.min(size(), other.size());
83 +            int r = 0;
84 +            for (int i = 0; i < common; i++) {
85 +                if ((r = get(i).compareTo(other.get(i))) != 0)
86 +                    break;
87 +            }
88 +            if (r == 0)
89 +                r = compare(size(), other.size());
90 +            return r;
91 +        }
92 +        private static final long serialVersionUID = 0;
93 +    }
94 +
95 +    static class CollidingObject {
96 +        final String value;
97 +        CollidingObject(final String value) { this.value = value; }
98 +        public int hashCode() { return this.value.hashCode() & 1; }
99 +        public boolean equals(final Object obj) {
100 +            return (obj instanceof CollidingObject) && ((CollidingObject)obj).value.equals(value);
101 +        }
102 +    }
103 +
104 +    static class ComparableCollidingObject extends CollidingObject implements Comparable<ComparableCollidingObject> {
105 +        ComparableCollidingObject(final String value) { super(value); }
106 +        public int compareTo(final ComparableCollidingObject o) {
107 +            return value.compareTo(o.value);
108 +        }
109 +    }
110 +
111 +    /**
112 +     * Inserted elements that are subclasses of the same Comparable
113 +     * class are found.
114 +     */
115 +    public void testComparableFamily() {
116 +        int size = 500;         // makes measured test run time -> 60ms
117 +        ConcurrentHashMap<BI, Boolean> m =
118 +            new ConcurrentHashMap<BI, Boolean>();
119 +        for (int i = 0; i < size; i++) {
120 +            assertTrue(m.put(new CI(i), true) == null);
121 +        }
122 +        for (int i = 0; i < size; i++) {
123 +            assertTrue(m.containsKey(new CI(i)));
124 +            assertTrue(m.containsKey(new DI(i)));
125 +        }
126 +    }
127 +
128 +    /**
129 +     * Elements of classes with erased generic type parameters based
130 +     * on Comparable can be inserted and found.
131 +     */
132 +    public void testGenericComparable() {
133 +        int size = 120;         // makes measured test run time -> 60ms
134 +        ConcurrentHashMap<Object, Boolean> m =
135 +            new ConcurrentHashMap<Object, Boolean>();
136 +        for (int i = 0; i < size; i++) {
137 +            BI bi = new BI(i);
138 +            BS bs = new BS(String.valueOf(i));
139 +            LexicographicList<BI> bis = new LexicographicList<BI>(bi);
140 +            LexicographicList<BS> bss = new LexicographicList<BS>(bs);
141 +            assertTrue(m.putIfAbsent(bis, true) == null);
142 +            assertTrue(m.containsKey(bis));
143 +            if (m.putIfAbsent(bss, true) == null)
144 +                assertTrue(m.containsKey(bss));
145 +            assertTrue(m.containsKey(bis));
146 +        }
147 +        for (int i = 0; i < size; i++) {
148 +            assertTrue(m.containsKey(Collections.singletonList(new BI(i))));
149 +        }
150 +    }
151 +
152 +    /**
153 +     * Elements of non-comparable classes equal to those of classes
154 +     * with erased generic type parameters based on Comparable can be
155 +     * inserted and found.
156 +     */
157 +    public void testGenericComparable2() {
158 +        int size = 500;         // makes measured test run time -> 60ms
159 +        ConcurrentHashMap<Object, Boolean> m =
160 +            new ConcurrentHashMap<Object, Boolean>();
161 +        for (int i = 0; i < size; i++) {
162 +            m.put(Collections.singletonList(new BI(i)), true);
163 +        }
164 +
165 +        for (int i = 0; i < size; i++) {
166 +            LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
167 +            assertTrue(m.containsKey(bis));
168 +        }
169 +    }
170 +
171 +    /**
172 +     * Mixtures of instances of comparable and non-comparable classes
173 +     * can be inserted and found.
174 +     */
175 +    public void testMixedComparable() {
176 +        int size = 1200;        // makes measured test run time -> 35ms
177 +        ConcurrentHashMap<Object, Object> map =
178 +            new ConcurrentHashMap<Object, Object>();
179 +        Random rng = new Random();
180 +        for (int i = 0; i < size; i++) {
181 +            Object x;
182 +            switch (rng.nextInt(4)) {
183 +            case 0:
184 +                x = new Object();
185 +                break;
186 +            case 1:
187 +                x = new CollidingObject(Integer.toString(i));
188 +                break;
189 +            default:
190 +                x = new ComparableCollidingObject(Integer.toString(i));
191 +            }
192 +            assertNull(map.put(x, x));
193 +        }
194 +        int count = 0;
195 +        for (Object k : map.keySet()) {
196 +            assertEquals(map.get(k), k);
197 +            ++count;
198 +        }
199 +        assertEquals(count, size);
200 +        assertEquals(map.size(), size);
201 +        for (Object k : map.keySet()) {
202 +            assertEquals(map.put(k, k), k);
203 +        }
204 +    }
205 +
206      /**
207       * clear removes all pairs
208       */
# Line 57 | Line 226 | public class ConcurrentHashMapTest exten
226      }
227  
228      /**
229 +     * hashCode() equals sum of each key.hashCode ^ value.hashCode
230 +     */
231 +    public void testHashCode() {
232 +        ConcurrentHashMap<Integer,String> map = map5();
233 +        int sum = 0;
234 +        for (Map.Entry<Integer,String> e : map.entrySet())
235 +            sum += e.getKey().hashCode() ^ e.getValue().hashCode();
236 +        assertEquals(sum, map.hashCode());
237 +    }
238 +
239 +    /**
240       * contains returns true for contained value
241       */
242      public void testContains() {
# Line 107 | Line 287 | public class ConcurrentHashMapTest exten
287          assertEquals("A", (String)map.get(one));
288          ConcurrentHashMap empty = new ConcurrentHashMap();
289          assertNull(map.get("anything"));
290 +        assertNull(empty.get("anything"));
291      }
292  
293      /**
# Line 340 | Line 521 | public class ConcurrentHashMapTest exten
521      // Exception tests
522  
523      /**
524 <     * Cannot create with negative capacity
524 >     * Cannot create with only negative capacity
525       */
526      public void testConstructor1() {
527          try {
528 <            new ConcurrentHashMap(-1,0,1);
528 >            new ConcurrentHashMap(-1);
529              shouldThrow();
530          } catch (IllegalArgumentException success) {}
531      }
532  
533      /**
534 <     * Cannot create with negative concurrency level
535 <     */
534 >     * Constructor (initialCapacity, loadFactor) throws
535 >     * IllegalArgumentException if either argument is negative
536 >      */
537      public void testConstructor2() {
538          try {
539 <            new ConcurrentHashMap(1,0,-1);
539 >            new ConcurrentHashMap(-1, .75f);
540 >            shouldThrow();
541 >        } catch (IllegalArgumentException success) {}
542 >
543 >        try {
544 >            new ConcurrentHashMap(16, -1);
545              shouldThrow();
546          } catch (IllegalArgumentException success) {}
547      }
548  
549      /**
550 <     * Cannot create with only negative capacity
550 >     * Constructor (initialCapacity, loadFactor, concurrencyLevel)
551 >     * throws IllegalArgumentException if any argument is negative
552       */
553      public void testConstructor3() {
554          try {
555 <            new ConcurrentHashMap(-1);
555 >            new ConcurrentHashMap(-1, .75f, 1);
556 >            shouldThrow();
557 >        } catch (IllegalArgumentException success) {}
558 >
559 >        try {
560 >            new ConcurrentHashMap(16, -1, 1);
561              shouldThrow();
562          } catch (IllegalArgumentException success) {}
563 +
564 +        try {
565 +            new ConcurrentHashMap(16, .75f, -1);
566 +            shouldThrow();
567 +        } catch (IllegalArgumentException success) {}
568 +    }
569 +
570 +    /**
571 +     * ConcurrentHashMap(map) throws NullPointerException if the given
572 +     * map is null
573 +     */
574 +    public void testConstructor4() {
575 +        try {
576 +            new ConcurrentHashMap(null);
577 +            shouldThrow();
578 +        } catch (NullPointerException success) {}
579 +    }
580 +
581 +    /**
582 +     * ConcurrentHashMap(map) creates a new map with the same mappings
583 +     * as the given map
584 +     */
585 +    public void testConstructor5() {
586 +        ConcurrentHashMap map1 = map5();
587 +        ConcurrentHashMap map2 = new ConcurrentHashMap(map5());
588 +        assertTrue(map2.equals(map1));
589 +        map2.put(one, "F");
590 +        assertFalse(map2.equals(map1));
591      }
592  
593      /**
594       * get(null) throws NPE
595       */
596      public void testGet_NullPointerException() {
597 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
598          try {
377 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
599              c.get(null);
600              shouldThrow();
601          } catch (NullPointerException success) {}
# Line 384 | Line 605 | public class ConcurrentHashMapTest exten
605       * containsKey(null) throws NPE
606       */
607      public void testContainsKey_NullPointerException() {
608 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
609          try {
388 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
610              c.containsKey(null);
611              shouldThrow();
612          } catch (NullPointerException success) {}
# Line 395 | Line 616 | public class ConcurrentHashMapTest exten
616       * containsValue(null) throws NPE
617       */
618      public void testContainsValue_NullPointerException() {
619 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
620          try {
399 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
621              c.containsValue(null);
622              shouldThrow();
623          } catch (NullPointerException success) {}
# Line 406 | Line 627 | public class ConcurrentHashMapTest exten
627       * contains(null) throws NPE
628       */
629      public void testContains_NullPointerException() {
630 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
631          try {
410 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
632              c.contains(null);
633              shouldThrow();
634          } catch (NullPointerException success) {}
# Line 417 | Line 638 | public class ConcurrentHashMapTest exten
638       * put(null,x) throws NPE
639       */
640      public void testPut1_NullPointerException() {
641 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
642          try {
421 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
643              c.put(null, "whatever");
644              shouldThrow();
645          } catch (NullPointerException success) {}
# Line 428 | Line 649 | public class ConcurrentHashMapTest exten
649       * put(x, null) throws NPE
650       */
651      public void testPut2_NullPointerException() {
652 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
653          try {
432 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
654              c.put("whatever", null);
655              shouldThrow();
656          } catch (NullPointerException success) {}
# Line 439 | Line 660 | public class ConcurrentHashMapTest exten
660       * putIfAbsent(null, x) throws NPE
661       */
662      public void testPutIfAbsent1_NullPointerException() {
663 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
664          try {
443 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
665              c.putIfAbsent(null, "whatever");
666              shouldThrow();
667          } catch (NullPointerException success) {}
# Line 450 | Line 671 | public class ConcurrentHashMapTest exten
671       * replace(null, x) throws NPE
672       */
673      public void testReplace_NullPointerException() {
674 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
675          try {
454 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
676              c.replace(null, "whatever");
677              shouldThrow();
678          } catch (NullPointerException success) {}
# Line 461 | Line 682 | public class ConcurrentHashMapTest exten
682       * replace(null, x, y) throws NPE
683       */
684      public void testReplaceValue_NullPointerException() {
685 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
686          try {
465 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
687              c.replace(null, one, "whatever");
688              shouldThrow();
689          } catch (NullPointerException success) {}
# Line 472 | Line 693 | public class ConcurrentHashMapTest exten
693       * putIfAbsent(x, null) throws NPE
694       */
695      public void testPutIfAbsent2_NullPointerException() {
696 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
697          try {
476 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
698              c.putIfAbsent("whatever", null);
699              shouldThrow();
700          } catch (NullPointerException success) {}
# Line 483 | Line 704 | public class ConcurrentHashMapTest exten
704       * replace(x, null) throws NPE
705       */
706      public void testReplace2_NullPointerException() {
707 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
708          try {
487 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
709              c.replace("whatever", null);
710              shouldThrow();
711          } catch (NullPointerException success) {}
# Line 494 | Line 715 | public class ConcurrentHashMapTest exten
715       * replace(x, null, y) throws NPE
716       */
717      public void testReplaceValue2_NullPointerException() {
718 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
719          try {
498 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
720              c.replace("whatever", null, "A");
721              shouldThrow();
722          } catch (NullPointerException success) {}
# Line 505 | Line 726 | public class ConcurrentHashMapTest exten
726       * replace(x, y, null) throws NPE
727       */
728      public void testReplaceValue3_NullPointerException() {
729 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
730          try {
509 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
731              c.replace("whatever", one, null);
732              shouldThrow();
733          } catch (NullPointerException success) {}
# Line 516 | Line 737 | public class ConcurrentHashMapTest exten
737       * remove(null) throws NPE
738       */
739      public void testRemove1_NullPointerException() {
740 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
741 +        c.put("sadsdf", "asdads");
742          try {
520 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
521 –            c.put("sadsdf", "asdads");
743              c.remove(null);
744              shouldThrow();
745          } catch (NullPointerException success) {}
# Line 528 | Line 749 | public class ConcurrentHashMapTest exten
749       * remove(null, x) throws NPE
750       */
751      public void testRemove2_NullPointerException() {
752 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
753 +        c.put("sadsdf", "asdads");
754          try {
532 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
533 –            c.put("sadsdf", "asdads");
755              c.remove(null, "whatever");
756              shouldThrow();
757          } catch (NullPointerException success) {}
# Line 552 | Line 773 | public class ConcurrentHashMapTest exten
773          Map x = map5();
774          Map y = serialClone(x);
775  
776 <        assertTrue(x != y);
776 >        assertNotSame(x, y);
777          assertEquals(x.size(), y.size());
778          assertEquals(x, y);
779          assertEquals(y, x);
# Line 569 | Line 790 | public class ConcurrentHashMapTest exten
790              map.put(new Integer(i), new Integer(i));
791          assertFalse(map.isEmpty());
792          Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next();
793 <
794 <        // assert that entry1 is not 16
795 <        assertTrue("entry is 16, test not valid",
796 <                   !entry1.getKey().equals(new Integer(16)));
797 <
798 <        // remove 16 (a different key) from map
799 <        // which just happens to cause entry1 to be cloned in map
800 <        map.remove(new Integer(16));
801 <        entry1.setValue("XYZ");
581 <        assertTrue(map.containsValue("XYZ")); // fails
793 >        // Unless it happens to be first (in which case remainder of
794 >        // test is skipped), remove a possibly-colliding key from map
795 >        // which, under some implementations, may cause entry1 to be
796 >        // cloned in map
797 >        if (!entry1.getKey().equals(new Integer(16))) {
798 >            map.remove(new Integer(16));
799 >            entry1.setValue("XYZ");
800 >            assertTrue(map.containsValue("XYZ")); // fails if write-through broken
801 >        }
802      }
803  
804   }

Diff Legend

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