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

Comparing jsr166/src/test/tck/ConcurrentHashMap8Test.java (file contents):
Revision 1.10 by jsr166, Thu May 30 03:28:55 2013 UTC vs.
Revision 1.22 by jsr166, Sat Jan 17 22:55:06 2015 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.function.*;
10 < import java.util.concurrent.atomic.LongAdder;
7 > import static java.util.Spliterator.CONCURRENT;
8 > import static java.util.Spliterator.DISTINCT;
9 > import static java.util.Spliterator.NONNULL;
10 >
11 > import java.util.AbstractMap;
12 > import java.util.Arrays;
13 > import java.util.Collection;
14 > import java.util.Collections;
15 > import java.util.Iterator;
16 > import java.util.Map;
17 > import java.util.NoSuchElementException;
18 > import java.util.Set;
19 > import java.util.Spliterator;
20 > import java.util.Vector;
21   import java.util.concurrent.ConcurrentHashMap;
22 + import java.util.concurrent.atomic.LongAdder;
23 + import java.util.function.BiFunction;
24 +
25 + import junit.framework.Test;
26 + import junit.framework.TestSuite;
27  
28   public class ConcurrentHashMap8Test extends JSR166TestCase {
29      public static void main(String[] args) {
# Line 53 | Line 68 | public class ConcurrentHashMap8Test exte
68      }
69  
70      /**
71 <     * computeIfAbsent does not replace  if the key is already present
71 >     * computeIfAbsent does not replace if the key is already present
72       */
73      public void testComputeIfAbsent2() {
74          ConcurrentHashMap map = map5();
# Line 70 | Line 85 | public class ConcurrentHashMap8Test exte
85      }
86  
87      /**
88 <     * computeIfPresent does not replace  if the key is already present
88 >     * computeIfPresent does not replace if the key is already present
89       */
90      public void testComputeIfPresent() {
91          ConcurrentHashMap map = map5();
# Line 87 | Line 102 | public class ConcurrentHashMap8Test exte
102      }
103  
104      /**
105 <     * compute does not replace  if the function returns null
105 >     * compute does not replace if the function returns null
106       */
107      public void testCompute() {
108          ConcurrentHashMap map = map5();
# Line 166 | Line 181 | public class ConcurrentHashMap8Test exte
181      }
182  
183      /**
184 +     * replaceAll replaces all matching values.
185 +     */
186 +    public void testReplaceAll() {
187 +        ConcurrentHashMap<Integer, String> map = map5();
188 +        map.replaceAll((x, y) -> { return x > 3 ? "Z" : y; });
189 +        assertEquals("A", map.get(one));
190 +        assertEquals("B", map.get(two));
191 +        assertEquals("C", map.get(three));
192 +        assertEquals("Z", map.get(four));
193 +        assertEquals("Z", map.get(five));
194 +    }
195 +
196 +    /**
197       * Default-constructed set is empty
198       */
199      public void testNewKeySet() {
# Line 174 | Line 202 | public class ConcurrentHashMap8Test exte
202      }
203  
204      /**
205 +     * keySet.add adds the key with the established value to the map;
206 +     * remove removes it.
207 +     */
208 +    public void testKeySetAddRemove() {
209 +        ConcurrentHashMap map = map5();
210 +        Set set1 = map.keySet();
211 +        Set set2 = map.keySet(true);
212 +        set2.add(six);
213 +        assertTrue(((ConcurrentHashMap.KeySetView)set2).getMap() == map);
214 +        assertTrue(((ConcurrentHashMap.KeySetView)set1).getMap() == map);
215 +        assertEquals(set2.size(), map.size());
216 +        assertEquals(set1.size(), map.size());
217 +        assertTrue((Boolean)map.get(six));
218 +        assertTrue(set1.contains(six));
219 +        assertTrue(set2.contains(six));
220 +        set2.remove(six);
221 +        assertNull(map.get(six));
222 +        assertFalse(set1.contains(six));
223 +        assertFalse(set2.contains(six));
224 +    }
225 +
226 +    /**
227       * keySet.addAll adds each element from the given collection
228       */
229      public void testAddAll() {
# Line 219 | Line 269 | public class ConcurrentHashMap8Test exte
269      }
270  
271      /**
272 +     * keySet.add throws UnsupportedOperationException if no default
273 +     * mapped value
274 +     */
275 +    public void testAdd4() {
276 +        Set full = map5().keySet();
277 +        try {
278 +            full.add(three);
279 +            shouldThrow();
280 +        } catch (UnsupportedOperationException e){}
281 +    }
282 +
283 +    /**
284 +     * keySet.add throws NullPointerException if the specified key is
285 +     * null
286 +     */
287 +    public void testAdd5() {
288 +        Set full = populatedSet(3);
289 +        try {
290 +            full.add(null);
291 +            shouldThrow();
292 +        } catch (NullPointerException e){}
293 +    }
294 +
295 +    /**
296 +     * KeySetView.getMappedValue returns the map's mapped value
297 +     */
298 +    public void testGetMappedValue() {
299 +        ConcurrentHashMap map = map5();
300 +        assertNull(map.keySet().getMappedValue());
301 +        try {
302 +            map.keySet(null);
303 +            shouldThrow();
304 +        } catch (NullPointerException e) {}
305 +        ConcurrentHashMap.KeySetView set = map.keySet(one);
306 +        set.add(one);
307 +        set.add(six);
308 +        set.add(seven);
309 +        assertTrue(set.getMappedValue() == one);
310 +        assertTrue(map.get(one) != one);
311 +        assertTrue(map.get(six) == one);
312 +        assertTrue(map.get(seven) == one);
313 +    }
314 +
315 +    void checkSpliteratorCharacteristics(Spliterator<?> sp,
316 +                                         int requiredCharacteristics) {
317 +        assertEquals(requiredCharacteristics,
318 +                     requiredCharacteristics & sp.characteristics());
319 +    }
320 +
321 +    /**
322 +     * KeySetView.spliterator returns spliterator over the elements in this set
323 +     */
324 +    public void testKeySetSpliterator() {
325 +        LongAdder adder = new LongAdder();
326 +        ConcurrentHashMap map = map5();
327 +        Set set = map.keySet();
328 +        Spliterator<Integer> sp = set.spliterator();
329 +        checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
330 +        assertEquals(sp.estimateSize(), map.size());
331 +        Spliterator<Integer> sp2 = sp.trySplit();
332 +        sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
333 +        long v = adder.sumThenReset();
334 +        sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
335 +        long v2 = adder.sum();
336 +        assertEquals(v + v2, 15);
337 +    }
338 +
339 +    /**
340       * keyset.clear removes all elements from the set
341       */
342      public void testClear() {
# Line 301 | Line 419 | public class ConcurrentHashMap8Test exte
419              assertTrue(it.hasNext());
420              it.next();
421          }
422 <        assertFalse(it.hasNext());
423 <        try {
424 <            it.next();
425 <            shouldThrow();
426 <        } catch (NoSuchElementException success) {}
422 >        assertIteratorExhausted(it);
423 >    }
424 >
425 >    /**
426 >     * iterator of empty collections has no elements
427 >     */
428 >    public void testEmptyIterator() {
429 >        assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
430 >        assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
431 >        assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
432 >        assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
433      }
434  
435      /**
# Line 433 | Line 557 | public class ConcurrentHashMap8Test exte
557  
558          assertNotSame(x, y);
559          assertEquals(x.size(), y.size());
436 –        assertEquals(x.toString(), y.toString());
437 –        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
560          assertEquals(x, y);
561          assertEquals(y, x);
562      }
563  
442 –
564      static final int SIZE = 10000;
565      static ConcurrentHashMap<Long, Long> longMap;
566  
# Line 637 | Line 758 | public class ConcurrentHashMap8Test exte
758          assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
759      }
760  
640 –
761      /**
762       * reduceKeysSequentially accumulates across all keys,
763       */
# Line 658 | Line 778 | public class ConcurrentHashMap8Test exte
778          assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
779      }
780  
661 –
781      /**
782       * reduceEntriesSequentially accumulates across all entries
783       */
# Line 761 | Line 880 | public class ConcurrentHashMap8Test exte
880          assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
881      }
882  
764 –
883      /**
884       * reduceKeysToLongSequentially accumulates mapped keys
885       */
# Line 890 | Line 1008 | public class ConcurrentHashMap8Test exte
1008      public void testSearchValuesSequentially() {
1009          ConcurrentHashMap<Long, Long> m = longMap();
1010          Long r;
1011 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1011 >        r = m.searchValues(Long.MAX_VALUE,
1012 >            (Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
1013          assertEquals((long)r, (long)(SIZE/2));
1014 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
1014 >        r = m.searchValues(Long.MAX_VALUE,
1015 >            (Long x) -> (x.longValue() < 0L) ? x : null);
1016          assertNull(r);
1017      }
1018  

Diff Legend

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