--- jsr166/src/test/tck/ConcurrentHashMap8Test.java	2013/04/11 19:54:13	1.7
+++ jsr166/src/test/tck/ConcurrentHashMap8Test.java	2013/07/14 16:35:48	1.11
@@ -34,105 +34,6 @@ public class ConcurrentHashMap8Test exte
         return map;
     }
 
-    // classes for testing Comparable fallbacks
-    static class BI implements Comparable<BI> {
-        private final int value;
-        BI(int value) { this.value = value; }
-        public int compareTo(BI other) {
-            return Integer.compare(value, other.value);
-        }
-        public boolean equals(Object x) {
-            return (x instanceof BI) && ((BI)x).value == value;
-        }
-        public int hashCode() { return 42; }
-    }
-    static class CI extends BI { CI(int value) { super(value); } }
-    static class DI extends BI { DI(int value) { super(value); } }
-
-    static class BS implements Comparable<BS> {
-        private final String value;
-        BS(String value) { this.value = value; }
-        public int compareTo(BS other) {
-            return value.compareTo(other.value);
-        }
-        public boolean equals(Object x) {
-            return (x instanceof BS) && value.equals(((BS)x).value);
-        }
-        public int hashCode() { return 42; }
-    }
-
-    static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
-        implements Comparable<LexicographicList<E>> {
-        LexicographicList(Collection<E> c) { super(c); }
-        LexicographicList(E e) { super(Collections.singleton(e)); }
-        public int compareTo(LexicographicList<E> other) {
-            int common = Math.min(size(), other.size());
-            int r = 0;
-            for (int i = 0; i < common; i++) {
-                if ((r = get(i).compareTo(other.get(i))) != 0)
-                    break;
-            }
-            if (r == 0)
-                r = Integer.compare(size(), other.size());
-            return r;
-        }
-        private static final long serialVersionUID = 0;
-    }
-
-    /**
-     * Inserted elements that are subclasses of the same Comparable
-     * class are found.
-     */
-    public void testComparableFamily() {
-        ConcurrentHashMap<BI, Boolean> m = new ConcurrentHashMap<>();
-        for (int i = 0; i < 1000; i++) {
-            assertTrue(m.put(new CI(i), true) == null);
-        }
-        for (int i = 0; i < 1000; i++) {
-            assertTrue(m.containsKey(new CI(i)));
-            assertTrue(m.containsKey(new DI(i)));
-        }
-    }
-
-    /**
-     * Elements of classes with erased generic type parameters based
-     * on Comparable can be inserted and found.
-     */
-    public void testGenericComparable() {
-        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
-        for (int i = 0; i < 1000; i++) {
-            BI bi = new BI(i);
-            BS bs = new BS(String.valueOf(i));
-            LexicographicList<BI> bis = new LexicographicList<BI>(bi);
-            LexicographicList<BS> bss = new LexicographicList<BS>(bs);
-            assertTrue(m.putIfAbsent(bis, true) == null);
-            assertTrue(m.containsKey(bis));
-            if (m.putIfAbsent(bss, true) == null)
-                assertTrue(m.containsKey(bss));
-            assertTrue(m.containsKey(bis));
-        }
-        for (int i = 0; i < 1000; i++) {
-            assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
-        }
-    }
-
-    /**
-     * Elements of non-comparable classes equal to those of classes
-     * with erased generic type parameters based on Comparable can be
-     * inserted and found.
-     */
-    public void testGenericComparable2() {
-        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
-        for (int i = 0; i < 1000; i++) {
-            m.put(new ArrayList(Collections.singleton(new BI(i))), true);
-        }
-
-        for (int i = 0; i < 1000; i++) {
-            LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
-            assertTrue(m.containsKey(bis));
-        }
-    }
-
     /**
      * getOrDefault returns value if present, else default
      */
@@ -530,7 +431,7 @@ public class ConcurrentHashMap8Test exte
         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()));
@@ -538,7 +439,6 @@ public class ConcurrentHashMap8Test exte
         assertEquals(y, x);
     }
 
-
     static final int SIZE = 10000;
     static ConcurrentHashMap<Long, Long> longMap;
 
@@ -566,7 +466,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);
     }
 
@@ -576,7 +476,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));
     }
 
@@ -586,7 +486,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);
     }
 
@@ -596,7 +496,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);
     }
 
@@ -606,7 +506,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);
     }
 
@@ -616,7 +516,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));
     }
 
@@ -626,7 +526,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);
     }
 
@@ -636,7 +536,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);
     }
 
@@ -647,7 +547,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);
     }
@@ -659,7 +559,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));
     }
@@ -671,7 +571,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);
     }
@@ -683,7 +583,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);
     }
@@ -695,7 +595,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);
     }
@@ -707,7 +607,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));
     }
@@ -719,7 +619,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);
     }
@@ -731,19 +631,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);
     }
 
@@ -753,18 +652,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);
     }
 
@@ -774,7 +672,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);
     }
 
@@ -784,7 +682,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));
     }
 
@@ -794,7 +692,7 @@ 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);
     }
 
@@ -803,7 +701,7 @@ public class ConcurrentHashMap8Test exte
      */
     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);
     }
@@ -813,7 +711,7 @@ public class ConcurrentHashMap8Test exte
      */
     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));
     }
@@ -823,7 +721,7 @@ 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);
@@ -834,7 +732,7 @@ public class ConcurrentHashMap8Test exte
      */
     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);
     }
@@ -844,7 +742,7 @@ public class ConcurrentHashMap8Test exte
      */
     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));
     }
@@ -855,18 +753,17 @@ 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);
     }
 
@@ -875,7 +772,7 @@ public class ConcurrentHashMap8Test exte
      */
     public void testReduceKeysToIntSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
+        int ir = m.reduceKeysToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
         assertEquals(ir, SIZE * (SIZE - 1) / 2);
     }
 
@@ -884,7 +781,7 @@ public class ConcurrentHashMap8Test exte
      */
     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);
     }
 
@@ -893,7 +790,7 @@ public class ConcurrentHashMap8Test exte
      */
     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));
     }
 
@@ -902,7 +799,7 @@ public class ConcurrentHashMap8Test exte
      */
     public void testReduceValuesToIntSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
+        int ir = m.reduceValuesToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
         assertEquals(ir, SIZE * (SIZE - 1));
     }
 
@@ -911,7 +808,7 @@ public class ConcurrentHashMap8Test exte
      */
     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));
     }
 
@@ -920,7 +817,7 @@ public class ConcurrentHashMap8Test exte
      */
     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);
     }
 
@@ -929,7 +826,7 @@ public class ConcurrentHashMap8Test exte
      */
     public void testReduceKeysToIntInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
+        int ir = m.reduceKeysToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
         assertEquals(ir, SIZE * (SIZE - 1) / 2);
     }
 
@@ -938,7 +835,7 @@ public class ConcurrentHashMap8Test exte
      */
     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);
     }
 
@@ -947,7 +844,7 @@ public class ConcurrentHashMap8Test exte
      */
     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));
     }
 
@@ -956,7 +853,7 @@ public class ConcurrentHashMap8Test exte
      */
     public void testReduceValuesToIntInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
-        int ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
+        int ir = m.reduceValuesToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
         assertEquals(ir, SIZE * (SIZE - 1));
     }
 
@@ -965,7 +862,7 @@ public class ConcurrentHashMap8Test exte
      */
     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));
     }
 
@@ -976,9 +873,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);
     }
 
@@ -989,9 +886,9 @@ 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);
     }
 
@@ -1002,9 +899,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);
     }
 
@@ -1015,9 +912,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);
     }
 
@@ -1028,9 +925,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);
     }
 
@@ -1041,9 +938,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);
     }
 
@@ -1054,9 +951,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);
     }
 
@@ -1067,109 +964,10 @@ 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, 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, 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));
-    }
 }