--- jsr166/src/test/tck/ConcurrentHashMap8Test.java	2013/03/22 16:10:19	1.4
+++ jsr166/src/test/tck/ConcurrentHashMap8Test.java	2018/05/28 21:36:41	1.37
@@ -4,15 +4,30 @@
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
-import junit.framework.*;
-import java.util.*;
-import java.util.function.*;
-import java.util.concurrent.atomic.LongAdder;
+import static java.util.Spliterator.CONCURRENT;
+import static java.util.Spliterator.DISTINCT;
+import static java.util.Spliterator.NONNULL;
+
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.LongAdder;
+import java.util.function.BiFunction;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
 
 public class ConcurrentHashMap8Test extends JSR166TestCase {
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
     public static Test suite() {
         return new TestSuite(ConcurrentHashMap8Test.class);
@@ -48,16 +63,16 @@ public class ConcurrentHashMap8Test exte
      */
     public void testComputeIfAbsent() {
         ConcurrentHashMap map = map5();
-        map.computeIfAbsent(six, (x) -> "Z");
+        map.computeIfAbsent(six, x -> "Z");
         assertTrue(map.containsKey(six));
     }
 
     /**
-     * computeIfAbsent does not replace  if the key is already present
+     * computeIfAbsent does not replace if the key is already present
      */
     public void testComputeIfAbsent2() {
         ConcurrentHashMap map = map5();
-        assertEquals("A", map.computeIfAbsent(one, (x) -> "Z"));
+        assertEquals("A", map.computeIfAbsent(one, x -> "Z"));
     }
 
     /**
@@ -65,12 +80,12 @@ public class ConcurrentHashMap8Test exte
      */
     public void testComputeIfAbsent3() {
         ConcurrentHashMap map = map5();
-        map.computeIfAbsent(six, (x) -> null);
+        map.computeIfAbsent(six, x -> null);
         assertFalse(map.containsKey(six));
     }
 
     /**
-     * computeIfPresent does not replace  if the key is already present
+     * computeIfPresent does not replace if the key is already present
      */
     public void testComputeIfPresent() {
         ConcurrentHashMap map = map5();
@@ -87,7 +102,7 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
-     * compute does not replace  if the function returns null
+     * compute does not replace if the function returns null
      */
     public void testCompute() {
         ConcurrentHashMap map = map5();
@@ -149,8 +164,8 @@ public class ConcurrentHashMap8Test exte
         Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
         assertTrue(a.isEmpty());
         for (int i = 0; i < n; i++)
-            a.add(i);
-        assertFalse(a.isEmpty());
+            assertTrue(a.add(i));
+        assertEquals(n == 0, a.isEmpty());
         assertEquals(n, a.size());
         return a;
     }
@@ -158,14 +173,27 @@ public class ConcurrentHashMap8Test exte
     static Set populatedSet(Integer[] elements) {
         Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
         assertTrue(a.isEmpty());
-        for (int i = 0; i < elements.length; i++)
-            a.add(elements[i]);
+        for (Integer element : elements)
+            assertTrue(a.add(element));
         assertFalse(a.isEmpty());
         assertEquals(elements.length, a.size());
         return a;
     }
 
     /**
+     * replaceAll replaces all matching values.
+     */
+    public void testReplaceAll() {
+        ConcurrentHashMap<Integer, String> map = map5();
+        map.replaceAll((x, y) -> (x > 3) ? "Z" : y);
+        assertEquals("A", map.get(one));
+        assertEquals("B", map.get(two));
+        assertEquals("C", map.get(three));
+        assertEquals("Z", map.get(four));
+        assertEquals("Z", map.get(five));
+    }
+
+    /**
      * Default-constructed set is empty
      */
     public void testNewKeySet() {
@@ -174,15 +202,35 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
+     * keySet.add adds the key with the established value to the map;
+     * remove removes it.
+     */
+    public void testKeySetAddRemove() {
+        ConcurrentHashMap map = map5();
+        Set set1 = map.keySet();
+        Set set2 = map.keySet(true);
+        set2.add(six);
+        assertSame(map, ((ConcurrentHashMap.KeySetView)set2).getMap());
+        assertSame(map, ((ConcurrentHashMap.KeySetView)set1).getMap());
+        assertEquals(set2.size(), map.size());
+        assertEquals(set1.size(), map.size());
+        assertTrue((Boolean)map.get(six));
+        assertTrue(set1.contains(six));
+        assertTrue(set2.contains(six));
+        set2.remove(six);
+        assertNull(map.get(six));
+        assertFalse(set1.contains(six));
+        assertFalse(set2.contains(six));
+    }
+
+    /**
      * keySet.addAll adds each element from the given collection
      */
     public void testAddAll() {
         Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(five);
-        full.addAll(v);
+        assertTrue(full.addAll(Arrays.asList(three, four, five)));
+        assertEquals(6, full.size());
+        assertFalse(full.addAll(Arrays.asList(three, four, five)));
         assertEquals(6, full.size());
     }
 
@@ -192,11 +240,10 @@ public class ConcurrentHashMap8Test exte
      */
     public void testAddAll2() {
         Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(one); // will not add this element
-        full.addAll(v);
+        // "one" is duplicate and will not be added
+        assertTrue(full.addAll(Arrays.asList(three, four, one)));
+        assertEquals(5, full.size());
+        assertFalse(full.addAll(Arrays.asList(three, four, one)));
         assertEquals(5, full.size());
     }
 
@@ -205,7 +252,7 @@ public class ConcurrentHashMap8Test exte
      */
     public void testAdd2() {
         Set full = populatedSet(3);
-        full.add(one);
+        assertFalse(full.add(one));
         assertEquals(3, full.size());
     }
 
@@ -214,11 +261,81 @@ public class ConcurrentHashMap8Test exte
      */
     public void testAdd3() {
         Set full = populatedSet(3);
-        full.add(three);
+        assertTrue(full.add(three));
+        assertTrue(full.contains(three));
+        assertFalse(full.add(three));
         assertTrue(full.contains(three));
     }
 
     /**
+     * keySet.add throws UnsupportedOperationException if no default
+     * mapped value
+     */
+    public void testAdd4() {
+        Set full = map5().keySet();
+        try {
+            full.add(three);
+            shouldThrow();
+        } catch (UnsupportedOperationException success) {}
+    }
+
+    /**
+     * keySet.add throws NullPointerException if the specified key is
+     * null
+     */
+    public void testAdd5() {
+        Set full = populatedSet(3);
+        try {
+            full.add(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * KeySetView.getMappedValue returns the map's mapped value
+     */
+    public void testGetMappedValue() {
+        ConcurrentHashMap map = map5();
+        assertNull(map.keySet().getMappedValue());
+        try {
+            map.keySet(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+        ConcurrentHashMap.KeySetView set = map.keySet(one);
+        assertFalse(set.add(one));
+        assertTrue(set.add(six));
+        assertTrue(set.add(seven));
+        assertSame(one, set.getMappedValue());
+        assertNotSame(one, map.get(one));
+        assertSame(one, map.get(six));
+        assertSame(one, map.get(seven));
+    }
+
+    void checkSpliteratorCharacteristics(Spliterator<?> sp,
+                                         int requiredCharacteristics) {
+        assertEquals(requiredCharacteristics,
+                     requiredCharacteristics & sp.characteristics());
+    }
+
+    /**
+     * KeySetView.spliterator returns spliterator over the elements in this set
+     */
+    public void testKeySetSpliterator() {
+        LongAdder adder = new LongAdder();
+        ConcurrentHashMap map = map5();
+        Set set = map.keySet();
+        Spliterator<Integer> sp = set.spliterator();
+        checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
+        assertEquals(sp.estimateSize(), map.size());
+        Spliterator<Integer> sp2 = sp.trySplit();
+        sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
+        long v = adder.sumThenReset();
+        sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
+        long v2 = adder.sum();
+        assertEquals(v + v2, 15);
+    }
+
+    /**
      * keyset.clear removes all elements from the set
      */
     public void testClear() {
@@ -258,23 +375,20 @@ public class ConcurrentHashMap8Test exte
      * KeySet.containsAll returns true for collections with subset of elements
      */
     public void testContainsAll() {
-        Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        assertTrue(full.containsAll(v));
-        v.add(six);
-        assertFalse(full.containsAll(v));
+        Collection full = populatedSet(3);
+        assertTrue(full.containsAll(Arrays.asList()));
+        assertTrue(full.containsAll(Arrays.asList(one)));
+        assertTrue(full.containsAll(Arrays.asList(one, two)));
+        assertFalse(full.containsAll(Arrays.asList(one, two, six)));
+        assertFalse(full.containsAll(Arrays.asList(six)));
     }
 
     /**
      * KeySet.isEmpty is true when empty, else false
      */
     public void testIsEmpty() {
-        Set empty = ConcurrentHashMap.newKeySet();
-        Set full = populatedSet(3);
-        assertTrue(empty.isEmpty());
-        assertFalse(full.isEmpty());
+        assertTrue(populatedSet(0).isEmpty());
+        assertFalse(populatedSet(3).isEmpty());
     }
 
     /**
@@ -293,7 +407,7 @@ public class ConcurrentHashMap8Test exte
         Integer[] elements = new Integer[size];
         for (int i = 0; i < size; i++)
             elements[i] = i;
-        Collections.shuffle(Arrays.asList(elements));
+        shuffle(elements);
         Collection<Integer> full = populatedSet(elements);
 
         Iterator it = full.iterator();
@@ -301,11 +415,17 @@ public class ConcurrentHashMap8Test exte
             assertTrue(it.hasNext());
             it.next();
         }
-        assertFalse(it.hasNext());
-        try {
-            it.next();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
+        assertIteratorExhausted(it);
+    }
+
+    /**
+     * iterator of empty collections has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
+        assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
+        assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
+        assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
     }
 
     /**
@@ -339,10 +459,9 @@ public class ConcurrentHashMap8Test exte
      */
     public void testRemoveAll() {
         Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        full.removeAll(v);
+        assertTrue(full.removeAll(Arrays.asList(one, two)));
+        assertEquals(1, full.size());
+        assertFalse(full.removeAll(Arrays.asList(one, two)));
         assertEquals(1, full.size());
     }
 
@@ -378,7 +497,7 @@ public class ConcurrentHashMap8Test exte
         Integer[] elements = new Integer[size];
         for (int i = 0; i < size; i++)
             elements[i] = i;
-        Collections.shuffle(Arrays.asList(elements));
+        shuffle(elements);
         Collection<Integer> full = populatedSet(elements);
 
         assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray())));
@@ -398,7 +517,7 @@ public class ConcurrentHashMap8Test exte
         a = new Integer[0];
         assertSame(a, empty.toArray(a));
 
-        a = new Integer[size/2];
+        a = new Integer[size / 2];
         Arrays.fill(a, 42);
         assertSame(a, empty.toArray(a));
         assertNull(a[0]);
@@ -408,7 +527,7 @@ public class ConcurrentHashMap8Test exte
         Integer[] elements = new Integer[size];
         for (int i = 0; i < size; i++)
             elements[i] = i;
-        Collections.shuffle(Arrays.asList(elements));
+        shuffle(elements);
         Collection<Integer> full = populatedSet(elements);
 
         Arrays.fill(a, 42);
@@ -424,22 +543,19 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
-     * A deserialized serialized set is equal
+     * A deserialized/reserialized set equals original
      */
     public void testSerialization() throws Exception {
         int size = 20;
         Set x = populatedSet(size);
         Set y = serialClone(x);
 
-        assertTrue(x != y);
+        assertNotSame(x, y);
         assertEquals(x.size(), y.size());
-        assertEquals(x.toString(), y.toString());
-        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
         assertEquals(x, y);
         assertEquals(y, x);
     }
 
-
     static final int SIZE = 10000;
     static ConcurrentHashMap<Long, Long> longMap;
 
@@ -467,7 +583,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachKeySequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachKeySequentially((Long x) -> adder.add(x.longValue()));
+        m.forEachKey(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
     }
 
@@ -477,7 +593,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachValueSequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachValueSequentially((Long x) -> adder.add(x.longValue()));
+        m.forEachValue(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), SIZE * (SIZE - 1));
     }
 
@@ -487,7 +603,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachSequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachSequentially((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
+        m.forEach(Long.MAX_VALUE, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
 
@@ -497,7 +613,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachEntrySequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
+        m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
 
@@ -507,7 +623,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachKeyInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachKeyInParallel((Long x) -> adder.add(x.longValue()));
+        m.forEachKey(1L, (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
     }
 
@@ -517,7 +633,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachValueInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachValueInParallel((Long x) -> adder.add(x.longValue()));
+        m.forEachValue(1L, (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), SIZE * (SIZE - 1));
     }
 
@@ -527,7 +643,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachInParallel((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
+        m.forEach(1L, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
 
@@ -537,7 +653,7 @@ public class ConcurrentHashMap8Test exte
     public void testForEachEntryInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
+        m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
 
@@ -548,7 +664,7 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachKeySequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachKeySequentially((Long x) -> Long.valueOf(4 * x.longValue()),
+        m.forEachKey(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
                                  (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
     }
@@ -560,7 +676,7 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachValueSequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachValueSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
+        m.forEachValue(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
                                    (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
     }
@@ -572,7 +688,7 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachSequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
+        m.forEach(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
                               (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
@@ -584,7 +700,7 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachEntrySequentially() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
+        m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
                                    (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
@@ -596,7 +712,7 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachKeyInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachKeyInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
+        m.forEachKey(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
                                (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
     }
@@ -608,7 +724,7 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachValueInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachValueInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
+        m.forEachValue(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
                                  (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
     }
@@ -620,7 +736,7 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
+        m.forEach(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
                             (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
@@ -632,19 +748,18 @@ public class ConcurrentHashMap8Test exte
     public void testMappedForEachEntryInParallel() {
         LongAdder adder = new LongAdder();
         ConcurrentHashMap<Long, Long> m = longMap();
-        m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
+        m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
                                  (Long x) -> adder.add(x.longValue()));
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
 
-
     /**
      * reduceKeysSequentially accumulates across all keys,
      */
     public void testReduceKeysSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.reduceKeysSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
+        r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
     }
 
@@ -654,18 +769,17 @@ public class ConcurrentHashMap8Test exte
     public void testReduceValuesSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.reduceKeysSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
+        r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
     }
 
-
     /**
      * reduceEntriesSequentially accumulates across all entries
      */
     public void testReduceEntriesSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Map.Entry<Long,Long> r;
-        r = m.reduceEntriesSequentially(new AddKeys());
+        r = m.reduceEntries(Long.MAX_VALUE, new AddKeys());
         assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
     }
 
@@ -675,7 +789,7 @@ public class ConcurrentHashMap8Test exte
     public void testReduceKeysInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.reduceKeysInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
+        r = m.reduceKeys(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
     }
 
@@ -685,7 +799,7 @@ public class ConcurrentHashMap8Test exte
     public void testReduceValuesInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.reduceValuesInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
+        r = m.reduceValues(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)SIZE * (SIZE - 1));
     }
 
@@ -695,26 +809,26 @@ public class ConcurrentHashMap8Test exte
     public void testReduceEntriesInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Map.Entry<Long,Long> r;
-        r = m.reduceEntriesInParallel(new AddKeys());
+        r = m.reduceEntries(1L, new AddKeys());
         assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceKeysSequentially accumulates mapped keys
      */
     public void testMapReduceKeysSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        Long r = m.reduceKeysSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
+        Long r = m.reduceKeys(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
                                      (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceValuesSequentially accumulates mapped values
      */
     public void testMapReduceValuesSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        Long r = m.reduceValuesSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
+        Long r = m.reduceValues(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
                                        (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
     }
@@ -724,28 +838,28 @@ public class ConcurrentHashMap8Test exte
      */
     public void testMappedReduceSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        Long r = m.reduceSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
+        Long r = m.reduce(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
                                  (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
 
         assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceKeysInParallel, accumulates mapped keys
      */
     public void testMapReduceKeysInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        Long r = m.reduceKeysInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
+        Long r = m.reduceKeys(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
                                    (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceValuesInParallel accumulates mapped values
      */
     public void testMapReduceValuesInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        Long r = m.reduceValuesInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
+        Long r = m.reduceValues(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
                                      (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
     }
@@ -756,117 +870,116 @@ public class ConcurrentHashMap8Test exte
     public void testMappedReduceInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.reduceInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
+        r = m.reduce(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
                                (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
         assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
     }
 
-
-    /*
+    /**
      * reduceKeysToLongSequentially accumulates mapped keys
      */
     public void testReduceKeysToLongSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        long lr = m.reduceKeysToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
+        long lr = m.reduceKeysToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
         assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToIntSequentially accumulates mapped keys
      */
     public void testReduceKeysToIntSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
+        int ir = m.reduceKeysToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
+        assertEquals(ir, SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToDoubleSequentially accumulates mapped keys
      */
     public void testReduceKeysToDoubleSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        double dr = m.reduceKeysToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
+        double dr = m.reduceKeysToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
         assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceValuesToLongSequentially accumulates mapped values
      */
     public void testReduceValuesToLongSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        long lr = m.reduceValuesToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
+        long lr = m.reduceValuesToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
         assertEquals(lr, (long)SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToIntSequentially accumulates mapped values
      */
     public void testReduceValuesToIntSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1));
+        int ir = m.reduceValuesToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
+        assertEquals(ir, SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToDoubleSequentially accumulates mapped values
      */
     public void testReduceValuesToDoubleSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        double dr = m.reduceValuesToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
+        double dr = m.reduceValuesToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
         assertEquals(dr, (double)SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceKeysToLongInParallel accumulates mapped keys
      */
     public void testReduceKeysToLongInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        long lr = m.reduceKeysToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
+        long lr = m.reduceKeysToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
         assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToIntInParallel accumulates mapped keys
      */
     public void testReduceKeysToIntInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
+        int ir = m.reduceKeysToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
+        assertEquals(ir, SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToDoubleInParallel accumulates mapped values
      */
     public void testReduceKeysToDoubleInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        double dr = m.reduceKeysToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
+        double dr = m.reduceKeysToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
         assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceValuesToLongInParallel accumulates mapped values
      */
     public void testReduceValuesToLongInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        long lr = m.reduceValuesToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
+        long lr = m.reduceValuesToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
         assertEquals(lr, (long)SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToIntInParallel accumulates mapped values
      */
     public void testReduceValuesToIntInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1));
+        int ir = m.reduceValuesToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
+        assertEquals(ir, SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToDoubleInParallel accumulates mapped values
      */
     public void testReduceValuesToDoubleInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        double dr = m.reduceValuesToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
+        double dr = m.reduceValuesToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
         assertEquals(dr, (double)SIZE * (SIZE - 1));
     }
 
@@ -877,9 +990,9 @@ public class ConcurrentHashMap8Test exte
     public void testSearchKeysSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchKeysSequentially((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
+        r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchKeysSequentially((Long x) -> x.longValue() < 0L ? x : null);
+        r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
         assertNull(r);
     }
 
@@ -890,9 +1003,11 @@ public class ConcurrentHashMap8Test exte
     public void testSearchValuesSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchValuesSequentially((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
+        r = m.searchValues(Long.MAX_VALUE,
+            (Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchValuesSequentially((Long x) -> x.longValue() < 0L ? x : null);
+        r = m.searchValues(Long.MAX_VALUE,
+            (Long x) -> (x.longValue() < 0L) ? x : null);
         assertNull(r);
     }
 
@@ -903,9 +1018,9 @@ public class ConcurrentHashMap8Test exte
     public void testSearchSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchSequentially((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
+        r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchSequentially((Long x, Long y) -> x.longValue() < 0L ? x : null);
+        r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() < 0L ? x : null);
         assertNull(r);
     }
 
@@ -916,9 +1031,9 @@ public class ConcurrentHashMap8Test exte
     public void testSearchEntriesSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
+        r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
+        r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
         assertNull(r);
     }
 
@@ -929,9 +1044,9 @@ public class ConcurrentHashMap8Test exte
     public void testSearchKeysInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchKeysInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
+        r = m.searchKeys(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchKeysInParallel((Long x) -> x.longValue() < 0L ? x : null);
+        r = m.searchKeys(1L, (Long x) -> x.longValue() < 0L ? x : null);
         assertNull(r);
     }
 
@@ -942,9 +1057,9 @@ public class ConcurrentHashMap8Test exte
     public void testSearchValuesInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchValuesInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
+        r = m.searchValues(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchValuesInParallel((Long x) -> x.longValue() < 0L ? x : null);
+        r = m.searchValues(1L, (Long x) -> x.longValue() < 0L ? x : null);
         assertNull(r);
     }
 
@@ -955,9 +1070,9 @@ public class ConcurrentHashMap8Test exte
     public void testSearchInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchInParallel((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
+        r = m.search(1L, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchInParallel((Long x, Long y) -> x.longValue() < 0L ? x : null);
+        r = m.search(1L, (Long x, Long y) -> x.longValue() < 0L ? x : null);
         assertNull(r);
     }
 
@@ -968,109 +1083,36 @@ public class ConcurrentHashMap8Test exte
     public void testSearchEntriesInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         Long r;
-        r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
+        r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
         assertEquals((long)r, (long)(SIZE/2));
-        r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
+        r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
         assertNull(r);
     }
 
     /**
-     * Invoking task versions of bulk methods has same effect as
-     * parallel methods
-     */
-    public void testForkJoinTasks() {
-        LongAdder adder = new LongAdder();
-        ConcurrentHashMap<Long, Long> m = longMap();
-        ConcurrentHashMap.ForkJoinTasks.forEachKey
-            (m, (Long x) -> adder.add(x.longValue())).invoke();
-        assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
-        adder.reset();
-        ConcurrentHashMap.ForkJoinTasks.forEachValue
-            (m, (Long x) -> adder.add(x.longValue())).invoke();
-        assertEquals(adder.sum(), SIZE * (SIZE - 1));
-        adder.reset();
-        ConcurrentHashMap.ForkJoinTasks.forEach
-            (m, (Long x, Long y) -> adder.add(x.longValue() + y.longValue())).invoke();
-        assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
-        adder.reset();
-        ConcurrentHashMap.ForkJoinTasks.forEachEntry
-            (m,
-             (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue())).invoke();
-        assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
-        adder.reset();
-        ConcurrentHashMap.ForkJoinTasks.forEachKey
-            (m, (Long x) -> Long.valueOf(4 * x.longValue()),
-             (Long x) -> adder.add(x.longValue())).invoke();
-        assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
-        adder.reset();
-        ConcurrentHashMap.ForkJoinTasks.forEachValue
-            (m, (Long x) -> Long.valueOf(4 * x.longValue()),
-             (Long x) -> adder.add(x.longValue())).invoke();
-        assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
-        adder.reset();
-        ConcurrentHashMap.ForkJoinTasks.forEach
-            (m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
-             (Long x) -> adder.add(x.longValue())).invoke();
-        assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
-        adder.reset();
-        ConcurrentHashMap.ForkJoinTasks.forEachEntry
-            (m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
-             (Long x) -> adder.add(x.longValue())).invoke();
-        assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
-        adder.reset();
-
-        Long r; long lr; int ir; double dr;
-        r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
-            (m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
-        assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
-        r = ConcurrentHashMap.ForkJoinTasks.reduceValues
-            (m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
-        assertEquals((long)r, (long)SIZE * (SIZE - 1));
-        r = ConcurrentHashMap.ForkJoinTasks.reduce
-            (m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
-             (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
-        assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
-        r = ConcurrentHashMap.ForkJoinTasks.reduceEntries
-            (m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
-             (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
-        assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
-        r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
-            (m, (Long x) -> Long.valueOf(4 * x.longValue()),
-             (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
-        assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
-        lr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToLong
-            (m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
-        assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
-        ir = ConcurrentHashMap.ForkJoinTasks.reduceKeysToInt
-            (m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
-        assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
-        dr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToDouble
-            (m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
-        assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
-        r = ConcurrentHashMap.ForkJoinTasks.reduceValues
-            (m, (Long x) -> Long.valueOf(4 * x.longValue()),
-             (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
-        assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
-        lr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToLong
-            (m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
-        assertEquals(lr, (long)SIZE * (SIZE - 1));
-        ir = ConcurrentHashMap.ForkJoinTasks.reduceValuesToInt
-            (m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
-        assertEquals(ir, (int)SIZE * (SIZE - 1));
-        dr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToDouble
-            (m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
-        assertEquals(dr, (double)SIZE * (SIZE - 1));
-        r = ConcurrentHashMap.ForkJoinTasks.searchKeys
-            (m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
-        assertEquals((long)r, (long)(SIZE/2));
-        r = ConcurrentHashMap.ForkJoinTasks.searchValues
-            (m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
-        assertEquals((long)r, (long)(SIZE/2));
-        r = ConcurrentHashMap.ForkJoinTasks.search
-            (m, (Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
-        assertEquals((long)r, (long)(SIZE/2));
-        r = ConcurrentHashMap.ForkJoinTasks.searchEntries
-            (m, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null).invoke();
-        assertEquals((long)r, (long)(SIZE/2));
+     * Tests performance of computeIfAbsent when the element is present.
+     * See JDK-8161372
+     * ant -Djsr166.tckTestClass=ConcurrentHashMapTest -Djsr166.methodFilter=testcomputeIfAbsent_performance -Djsr166.expensiveTests=true tck
+     */
+    public void testcomputeIfAbsent_performance() {
+        final int mapSize = 20;
+        final int iterations = expensiveTests ? (1 << 23) : mapSize * 2;
+        final int threads = expensiveTests ? 10 : 2;
+        final ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>();
+        for (int i = 0; i < mapSize; i++)
+            map.put(i, i);
+        final ExecutorService pool = Executors.newFixedThreadPool(2);
+        try (PoolCleaner cleaner = cleaner(pool)) {
+            Runnable r = new CheckedRunnable() {
+                public void realRun() {
+                    int result = 0;
+                    for (int i = 0; i < iterations; i++)
+                        result += map.computeIfAbsent(i % mapSize, k -> k + k);
+                    if (result == -42) throw new Error();
+                }};
+            for (int i = 0; i < threads; i++)
+                pool.execute(r);
+        }
     }
+
 }