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.31 by jsr166, Thu May 30 03:28:55 2013 UTC vs.
Revision 1.36 by dl, Sun Jul 21 22:24:18 2013 UTC

# Line 21 | Line 21 | public class ConcurrentHashMapTest exten
21      /**
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);
24 >    private static ConcurrentHashMap<Integer, String> map5() {
25 >        ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5);
26          assertTrue(map.isEmpty());
27          map.put(one, "A");
28          map.put(two, "B");
# Line 34 | 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 Integer.compare(value, other.value);
45 >            return compare(value, other.value);
46          }
47          public boolean equals(Object x) {
48              return (x instanceof BI) && ((BI)x).value == value;
# Line 73 | Line 76 | public class ConcurrentHashMapTest exten
76                      break;
77              }
78              if (r == 0)
79 <                r = Integer.compare(size(), other.size());
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 = new ConcurrentHashMap<>();
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          }
# Line 99 | Line 119 | public class ConcurrentHashMapTest exten
119       * on Comparable can be inserted and found.
120       */
121      public void testGenericComparable() {
122 <        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
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));
# Line 122 | Line 143 | public class ConcurrentHashMapTest exten
143       * inserted and found.
144       */
145      public void testGenericComparable2() {
146 <        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
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          }
# Line 134 | Line 156 | public class ConcurrentHashMapTest exten
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
195       */
196      public void testClear() {
# Line 155 | Line 212 | public class ConcurrentHashMapTest exten
212          assertFalse(map2.equals(map1));
213      }
214  
215 +
216 +    /**
217 +      * hashCode() equals sum of each key.hashCode ^ value.hashCode
218 +      */
219 +    public void testHashCode() {
220 +        ConcurrentHashMap<Integer,String> map = map5();
221 +        int sum = 0;
222 +        for (Map.Entry<Integer,String> e : map.entrySet())
223 +            sum += e.getKey().hashCode() ^ e.getValue().hashCode();
224 +        assertEquals(sum, map.hashCode());
225 +    }
226 +
227      /**
228       * contains returns true for contained value
229       */
# Line 439 | Line 508 | public class ConcurrentHashMapTest exten
508      // Exception tests
509  
510      /**
511 <     * Cannot create with negative capacity
511 >     * Cannot create with only negative capacity
512       */
513      public void testConstructor1() {
514          try {
515 <            new ConcurrentHashMap(-1,0,1);
515 >            new ConcurrentHashMap(-1);
516              shouldThrow();
517          } catch (IllegalArgumentException success) {}
518      }
519  
520      /**
521 <     * Cannot create with negative concurrency level
522 <     */
521 >     * Constructor (initialCapacity, loadFactor) throws
522 >     * IllegalArgumentException if either argument is negative
523 >      */
524      public void testConstructor2() {
525          try {
526 <            new ConcurrentHashMap(1,0,-1);
526 >            new ConcurrentHashMap(-1, .75f);
527              shouldThrow();
528 <        } catch (IllegalArgumentException success) {}
528 >        } catch (IllegalArgumentException e) {}        
529 >        
530 >        try {
531 >            new ConcurrentHashMap(16, -1);
532 >            shouldThrow();
533 >        } catch (IllegalArgumentException e) {}        
534      }
535 +    
536 +     /**
537 +      * Constructor (initialCapacity, loadFactor, concurrencyLevel)
538 +      * throws IllegalArgumentException if any argument is negative
539 +      */
540 +    public void testConstructor3() {
541 +         try {
542 +             new ConcurrentHashMap(-1, .75f, 1);
543 +             shouldThrow();
544 +         } catch (IllegalArgumentException e) {}        
545 +
546 +         try {
547 +             new ConcurrentHashMap(16, -1, 1);
548 +             shouldThrow();
549 +         } catch (IllegalArgumentException e) {}
550 +        
551 +         try {
552 +             new ConcurrentHashMap(16, .75f, -1);
553 +             shouldThrow();
554 +         } catch (IllegalArgumentException e) {}
555 +     }
556  
557      /**
558 <     * Cannot create with only negative capacity
558 >     * ConcurrentHashMap(map) throws NullPointerException if the given
559 >     * map is null
560       */
561 <    public void testConstructor3() {
561 >    public void testConstructor4() {
562          try {
563 <            new ConcurrentHashMap(-1);
563 >            new ConcurrentHashMap(null);
564              shouldThrow();
565 <        } catch (IllegalArgumentException success) {}
565 >        } catch (NullPointerException e) {}
566      }
567  
568      /**
569 +     * ConcurrentHashMap(map) creates a new map with the same mappings
570 +     * as the given map
571 +     */
572 +    public void testConstructor5() {
573 +        ConcurrentHashMap map1 = map5();
574 +        ConcurrentHashMap map2 = new ConcurrentHashMap(map5());
575 +        assertTrue(map2.equals(map1));
576 +        map2.put(one, "F");
577 +        assertFalse(map2.equals(map1));
578 +    }
579 +
580 +
581 +    /**
582       * get(null) throws NPE
583       */
584      public void testGet_NullPointerException() {

Diff Legend

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