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.35 by jsr166, Sat Jul 20 16:53:40 2013 UTC

# 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 133 | Line 155 | public class ConcurrentHashMapTest exten
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
195       */

Diff Legend

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