ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ConcurrentHashMap8Test.java

Comparing jsr166/src/test/tck/ConcurrentHashMap8Test.java (file contents):
Revision 1.6 by dl, Thu Apr 11 19:15:20 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 34 | Line 49 | public class ConcurrentHashMap8Test exte
49		return map;
50		}
51
37	–	// classes for testing Comparable fallbacks
38	–	static class BI implements Comparable<BI> {
39	–	private final int value;
40	–	BI(int value) { this.value = value; }
41	–	public int compareTo(BI other) {
42	–	return Integer.compare(value, other.value);
43	–	}
44	–	public boolean equals(Object x) {
45	–	return (x instanceof BI) && ((BI)x).value == value;
46	–	}
47	–	public int hashCode() { return 42; }
48	–	}
49	–	static class CI extends BI { CI(int value) { super(value); } }
50	–	static class DI extends BI { DI(int value) { super(value); } }
51	–
52	–	static class BS implements Comparable<BS> {
53	–	private final String value;
54	–	BS(String value) { this.value = value; }
55	–	public int compareTo(BS other) {
56	–	return value.compareTo(other.value);
57	–	}
58	–	public boolean equals(Object x) {
59	–	return (x instanceof BS) && value.equals(((BS)x).value);
60	–	}
61	–	public int hashCode() { return 42; }
62	–	}
63	–
64	–	static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
65	–	implements Comparable<LexicographicList<E>> {
66	–	LexicographicList(Collection<E> c) { super(c); }
67	–	LexicographicList(E e) { super(Collections.singleton(e)); }
68	–	public int compareTo(LexicographicList<E> other) {
69	–	int common = Math.min(size(), other.size());
70	–	int r = 0;
71	–	for (int i = 0; i < common; i++) {
72	–	if ((r = get(i).compareTo(other.get(i))) != 0)
73	–	break;
74	–	}
75	–	if (r == 0)
76	–	r = Integer.compare(size(), other.size());
77	–	return r;
78	–	}
79	–	private static final long serialVersionUID = 0;
80	–	}
81	–
82	–	/**
83	–	* Inserted elements that are subclasses of the same Comparable
84	–	* class are found.
85	–	*/
86	–	public void testComparableFamily() {
87	–	ConcurrentHashMap<BI, Boolean> m = new ConcurrentHashMap<>();
88	–	for (int i = 0; i < 1000; i++) {
89	–	assertTrue(m.put(new CI(i), true) == null);
90	–	}
91	–	for (int i = 0; i < 1000; i++) {
92	–	assertTrue(m.containsKey(new CI(i)));
93	–	assertTrue(m.containsKey(new DI(i)));
94	–	}
95	–	}
96	–
97	–	/**
98	–	* Elements of classes with erased generic type parameters based
99	–	* on Comparable can be inserted and found.
100	–	*/
101	–	public void testGenericComparable() {
102	–	ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
103	–	for (int i = 0; i < 1000; i++) {
104	–	BI bi = new BI(i);
105	–	BS bs = new BS(String.valueOf(i));
106	–	LexicographicList<BI> bis = new LexicographicList<BI>(bi);
107	–	LexicographicList<BS> bss = new LexicographicList<BS>(bs);
108	–	assertTrue(m.putIfAbsent(bis, true) == null);
109	–	assertTrue(m.containsKey(bis));
110	–	if (m.putIfAbsent(bss, true) == null)
111	–	assertTrue(m.containsKey(bss));
112	–	assertTrue(m.containsKey(bis));
113	–	}
114	–	for (int i = 0; i < 1000; i++) {
115	–	assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
116	–	}
117	–	}
118	–
119	–	/**
120	–	* Elements of non-comparable classes equal to those of classes
121	–	* with erased generic type parameters based on Comparable can be
122	–	* inserted and found.
123	–	*/
124	–	public void testGenericComparable2() {
125	–	ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
126	–	for (int i = 0; i < 1000; i++) {
127	–	m.put(new ArrayList(Collections.singleton(new BI(i))), true);
128	–	}
129	–
130	–	for (int i = 0; i < 1000; i++) {
131	–	LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
132	–	assertTrue(m.containsKey(bis));
133	–	}
134	–	}
135	–
52		/**
53		* getOrDefault returns value if present, else default
54		*/
#	Line 152 | 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 169 | 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 186 | 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 265 | 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 273 | 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 318 | 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 400 | 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 530 | Line 555 | public class ConcurrentHashMap8Test exte
555		Set x = populatedSet(size);
556		Set y = serialClone(x);
557
558	<	assertTrue(x != y);
558	>	assertNotSame(x, y);
559		assertEquals(x.size(), y.size());
535	–	assertEquals(x.toString(), y.toString());
536	–	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
560		assertEquals(x, y);
561		assertEquals(y, x);
562		}
563
541	–
564		static final int SIZE = 10000;
565		static ConcurrentHashMap<Long, Long> longMap;
566
#	Line 566 | Line 588 | public class ConcurrentHashMap8Test exte
588		public void testForEachKeySequentially() {
589		LongAdder adder = new LongAdder();
590		ConcurrentHashMap<Long, Long> m = longMap();
591	<	m.forEachKeySequentially((Long x) -> adder.add(x.longValue()));
591	>	m.forEachKey(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
592		assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
593		}
594
#	Line 576 | Line 598 | public class ConcurrentHashMap8Test exte
598		public void testForEachValueSequentially() {
599		LongAdder adder = new LongAdder();
600		ConcurrentHashMap<Long, Long> m = longMap();
601	<	m.forEachValueSequentially((Long x) -> adder.add(x.longValue()));
601	>	m.forEachValue(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
602		assertEquals(adder.sum(), SIZE * (SIZE - 1));
603		}
604
#	Line 586 | Line 608 | public class ConcurrentHashMap8Test exte
608		public void testForEachSequentially() {
609		LongAdder adder = new LongAdder();
610		ConcurrentHashMap<Long, Long> m = longMap();
611	<	m.forEachSequentially((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
611	>	m.forEach(Long.MAX_VALUE, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
612		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
613		}
614
#	Line 596 | Line 618 | public class ConcurrentHashMap8Test exte
618		public void testForEachEntrySequentially() {
619		LongAdder adder = new LongAdder();
620		ConcurrentHashMap<Long, Long> m = longMap();
621	<	m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
621	>	m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
622		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
623		}
624
#	Line 606 | Line 628 | public class ConcurrentHashMap8Test exte
628		public void testForEachKeyInParallel() {
629		LongAdder adder = new LongAdder();
630		ConcurrentHashMap<Long, Long> m = longMap();
631	<	m.forEachKeyInParallel((Long x) -> adder.add(x.longValue()));
631	>	m.forEachKey(1L, (Long x) -> adder.add(x.longValue()));
632		assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
633		}
634
#	Line 616 | Line 638 | public class ConcurrentHashMap8Test exte
638		public void testForEachValueInParallel() {
639		LongAdder adder = new LongAdder();
640		ConcurrentHashMap<Long, Long> m = longMap();
641	<	m.forEachValueInParallel((Long x) -> adder.add(x.longValue()));
641	>	m.forEachValue(1L, (Long x) -> adder.add(x.longValue()));
642		assertEquals(adder.sum(), SIZE * (SIZE - 1));
643		}
644
#	Line 626 | Line 648 | public class ConcurrentHashMap8Test exte
648		public void testForEachInParallel() {
649		LongAdder adder = new LongAdder();
650		ConcurrentHashMap<Long, Long> m = longMap();
651	<	m.forEachInParallel((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
651	>	m.forEach(1L, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
652		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
653		}
654
#	Line 636 | Line 658 | public class ConcurrentHashMap8Test exte
658		public void testForEachEntryInParallel() {
659		LongAdder adder = new LongAdder();
660		ConcurrentHashMap<Long, Long> m = longMap();
661	<	m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
661	>	m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
662		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
663		}
664
#	Line 647 | Line 669 | public class ConcurrentHashMap8Test exte
669		public void testMappedForEachKeySequentially() {
670		LongAdder adder = new LongAdder();
671		ConcurrentHashMap<Long, Long> m = longMap();
672	<	m.forEachKeySequentially((Long x) -> Long.valueOf(4 * x.longValue()),
672	>	m.forEachKey(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
673		(Long x) -> adder.add(x.longValue()));
674		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
675		}
#	Line 659 | Line 681 | public class ConcurrentHashMap8Test exte
681		public void testMappedForEachValueSequentially() {
682		LongAdder adder = new LongAdder();
683		ConcurrentHashMap<Long, Long> m = longMap();
684	<	m.forEachValueSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
684	>	m.forEachValue(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
685		(Long x) -> adder.add(x.longValue()));
686		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
687		}
#	Line 671 | Line 693 | public class ConcurrentHashMap8Test exte
693		public void testMappedForEachSequentially() {
694		LongAdder adder = new LongAdder();
695		ConcurrentHashMap<Long, Long> m = longMap();
696	<	m.forEachSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
696	>	m.forEach(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
697		(Long x) -> adder.add(x.longValue()));
698		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
699		}
#	Line 683 | Line 705 | public class ConcurrentHashMap8Test exte
705		public void testMappedForEachEntrySequentially() {
706		LongAdder adder = new LongAdder();
707		ConcurrentHashMap<Long, Long> m = longMap();
708	<	m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
708	>	m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
709		(Long x) -> adder.add(x.longValue()));
710		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
711		}
#	Line 695 | Line 717 | public class ConcurrentHashMap8Test exte
717		public void testMappedForEachKeyInParallel() {
718		LongAdder adder = new LongAdder();
719		ConcurrentHashMap<Long, Long> m = longMap();
720	<	m.forEachKeyInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
720	>	m.forEachKey(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
721		(Long x) -> adder.add(x.longValue()));
722		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
723		}
#	Line 707 | Line 729 | public class ConcurrentHashMap8Test exte
729		public void testMappedForEachValueInParallel() {
730		LongAdder adder = new LongAdder();
731		ConcurrentHashMap<Long, Long> m = longMap();
732	<	m.forEachValueInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
732	>	m.forEachValue(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
733		(Long x) -> adder.add(x.longValue()));
734		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
735		}
#	Line 719 | Line 741 | public class ConcurrentHashMap8Test exte
741		public void testMappedForEachInParallel() {
742		LongAdder adder = new LongAdder();
743		ConcurrentHashMap<Long, Long> m = longMap();
744	<	m.forEachInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
744	>	m.forEach(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
745		(Long x) -> adder.add(x.longValue()));
746		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
747		}
#	Line 731 | Line 753 | public class ConcurrentHashMap8Test exte
753		public void testMappedForEachEntryInParallel() {
754		LongAdder adder = new LongAdder();
755		ConcurrentHashMap<Long, Long> m = longMap();
756	<	m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
756	>	m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
757		(Long x) -> adder.add(x.longValue()));
758		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
759		}
760
739	–
761		/**
762		* reduceKeysSequentially accumulates across all keys,
763		*/
764		public void testReduceKeysSequentially() {
765		ConcurrentHashMap<Long, Long> m = longMap();
766		Long r;
767	<	r = m.reduceKeysSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
767	>	r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
768		assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
769		}
770
#	Line 753 | Line 774 | public class ConcurrentHashMap8Test exte
774		public void testReduceValuesSequentially() {
775		ConcurrentHashMap<Long, Long> m = longMap();
776		Long r;
777	<	r = m.reduceKeysSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
777	>	r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
778		assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
779		}
780
760	–
781		/**
782		* reduceEntriesSequentially accumulates across all entries
783		*/
784		public void testReduceEntriesSequentially() {
785		ConcurrentHashMap<Long, Long> m = longMap();
786		Map.Entry<Long,Long> r;
787	<	r = m.reduceEntriesSequentially(new AddKeys());
787	>	r = m.reduceEntries(Long.MAX_VALUE, new AddKeys());
788		assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
789		}
790
#	Line 774 | Line 794 | public class ConcurrentHashMap8Test exte
794		public void testReduceKeysInParallel() {
795		ConcurrentHashMap<Long, Long> m = longMap();
796		Long r;
797	<	r = m.reduceKeysInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
797	>	r = m.reduceKeys(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
798		assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
799		}
800
#	Line 784 | Line 804 | public class ConcurrentHashMap8Test exte
804		public void testReduceValuesInParallel() {
805		ConcurrentHashMap<Long, Long> m = longMap();
806		Long r;
807	<	r = m.reduceValuesInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
807	>	r = m.reduceValues(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
808		assertEquals((long)r, (long)SIZE * (SIZE - 1));
809		}
810
#	Line 794 | Line 814 | public class ConcurrentHashMap8Test exte
814		public void testReduceEntriesInParallel() {
815		ConcurrentHashMap<Long, Long> m = longMap();
816		Map.Entry<Long,Long> r;
817	<	r = m.reduceEntriesInParallel(new AddKeys());
817	>	r = m.reduceEntries(1L, new AddKeys());
818		assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
819		}
820
821	<	/*
821	>	/**
822		* Mapped reduceKeysSequentially accumulates mapped keys
823		*/
824		public void testMapReduceKeysSequentially() {
825		ConcurrentHashMap<Long, Long> m = longMap();
826	<	Long r = m.reduceKeysSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
826	>	Long r = m.reduceKeys(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
827		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
828		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
829		}
830
831	<	/*
831	>	/**
832		* Mapped reduceValuesSequentially accumulates mapped values
833		*/
834		public void testMapReduceValuesSequentially() {
835		ConcurrentHashMap<Long, Long> m = longMap();
836	<	Long r = m.reduceValuesSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
836	>	Long r = m.reduceValues(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
837		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
838		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
839		}
#	Line 823 | Line 843 | public class ConcurrentHashMap8Test exte
843		*/
844		public void testMappedReduceSequentially() {
845		ConcurrentHashMap<Long, Long> m = longMap();
846	<	Long r = m.reduceSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
846	>	Long r = m.reduce(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
847		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
848
849		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
850		}
851
852	<	/*
852	>	/**
853		* Mapped reduceKeysInParallel, accumulates mapped keys
854		*/
855		public void testMapReduceKeysInParallel() {
856		ConcurrentHashMap<Long, Long> m = longMap();
857	<	Long r = m.reduceKeysInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
857	>	Long r = m.reduceKeys(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
858		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
859		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
860		}
861
862	<	/*
862	>	/**
863		* Mapped reduceValuesInParallel accumulates mapped values
864		*/
865		public void testMapReduceValuesInParallel() {
866		ConcurrentHashMap<Long, Long> m = longMap();
867	<	Long r = m.reduceValuesInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
867	>	Long r = m.reduceValues(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
868		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
869		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
870		}
#	Line 855 | Line 875 | public class ConcurrentHashMap8Test exte
875		public void testMappedReduceInParallel() {
876		ConcurrentHashMap<Long, Long> m = longMap();
877		Long r;
878	<	r = m.reduceInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
878	>	r = m.reduce(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
879		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
880		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
881		}
882
883	<
864	<	/*
883	>	/**
884		* reduceKeysToLongSequentially accumulates mapped keys
885		*/
886		public void testReduceKeysToLongSequentially() {
887		ConcurrentHashMap<Long, Long> m = longMap();
888	<	long lr = m.reduceKeysToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
888	>	long lr = m.reduceKeysToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
889		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
890		}
891
892	<	/*
892	>	/**
893		* reduceKeysToIntSequentially accumulates mapped keys
894		*/
895		public void testReduceKeysToIntSequentially() {
896		ConcurrentHashMap<Long, Long> m = longMap();
897	<	int ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
897	>	int ir = m.reduceKeysToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
898		assertEquals(ir, SIZE * (SIZE - 1) / 2);
899		}
900
901	<	/*
901	>	/**
902		* reduceKeysToDoubleSequentially accumulates mapped keys
903		*/
904		public void testReduceKeysToDoubleSequentially() {
905		ConcurrentHashMap<Long, Long> m = longMap();
906	<	double dr = m.reduceKeysToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
906	>	double dr = m.reduceKeysToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
907		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
908		}
909
910	<	/*
910	>	/**
911		* reduceValuesToLongSequentially accumulates mapped values
912		*/
913		public void testReduceValuesToLongSequentially() {
914		ConcurrentHashMap<Long, Long> m = longMap();
915	<	long lr = m.reduceValuesToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
915	>	long lr = m.reduceValuesToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
916		assertEquals(lr, (long)SIZE * (SIZE - 1));
917		}
918
919	<	/*
919	>	/**
920		* reduceValuesToIntSequentially accumulates mapped values
921		*/
922		public void testReduceValuesToIntSequentially() {
923		ConcurrentHashMap<Long, Long> m = longMap();
924	<	int ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
924	>	int ir = m.reduceValuesToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
925		assertEquals(ir, SIZE * (SIZE - 1));
926		}
927
928	<	/*
928	>	/**
929		* reduceValuesToDoubleSequentially accumulates mapped values
930		*/
931		public void testReduceValuesToDoubleSequentially() {
932		ConcurrentHashMap<Long, Long> m = longMap();
933	<	double dr = m.reduceValuesToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
933	>	double dr = m.reduceValuesToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
934		assertEquals(dr, (double)SIZE * (SIZE - 1));
935		}
936
937	<	/*
937	>	/**
938		* reduceKeysToLongInParallel accumulates mapped keys
939		*/
940		public void testReduceKeysToLongInParallel() {
941		ConcurrentHashMap<Long, Long> m = longMap();
942	<	long lr = m.reduceKeysToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
942	>	long lr = m.reduceKeysToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
943		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
944		}
945
946	<	/*
946	>	/**
947		* reduceKeysToIntInParallel accumulates mapped keys
948		*/
949		public void testReduceKeysToIntInParallel() {
950		ConcurrentHashMap<Long, Long> m = longMap();
951	<	int ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
951	>	int ir = m.reduceKeysToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
952		assertEquals(ir, SIZE * (SIZE - 1) / 2);
953		}
954
955	<	/*
955	>	/**
956		* reduceKeysToDoubleInParallel accumulates mapped values
957		*/
958		public void testReduceKeysToDoubleInParallel() {
959		ConcurrentHashMap<Long, Long> m = longMap();
960	<	double dr = m.reduceKeysToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
960	>	double dr = m.reduceKeysToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
961		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
962		}
963
964	<	/*
964	>	/**
965		* reduceValuesToLongInParallel accumulates mapped values
966		*/
967		public void testReduceValuesToLongInParallel() {
968		ConcurrentHashMap<Long, Long> m = longMap();
969	<	long lr = m.reduceValuesToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
969	>	long lr = m.reduceValuesToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
970		assertEquals(lr, (long)SIZE * (SIZE - 1));
971		}
972
973	<	/*
973	>	/**
974		* reduceValuesToIntInParallel accumulates mapped values
975		*/
976		public void testReduceValuesToIntInParallel() {
977		ConcurrentHashMap<Long, Long> m = longMap();
978	<	int ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
978	>	int ir = m.reduceValuesToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
979		assertEquals(ir, SIZE * (SIZE - 1));
980		}
981
982	<	/*
982	>	/**
983		* reduceValuesToDoubleInParallel accumulates mapped values
984		*/
985		public void testReduceValuesToDoubleInParallel() {
986		ConcurrentHashMap<Long, Long> m = longMap();
987	<	double dr = m.reduceValuesToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
987	>	double dr = m.reduceValuesToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
988		assertEquals(dr, (double)SIZE * (SIZE - 1));
989		}
990
#	Line 976 | Line 995 | public class ConcurrentHashMap8Test exte
995		public void testSearchKeysSequentially() {
996		ConcurrentHashMap<Long, Long> m = longMap();
997		Long r;
998	<	r = m.searchKeysSequentially((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
998	>	r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
999		assertEquals((long)r, (long)(SIZE/2));
1000	<	r = m.searchKeysSequentially((Long x) -> x.longValue() < 0L ? x : null);
1000	>	r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
1001		assertNull(r);
1002		}
1003
#	Line 989 | Line 1008 | public class ConcurrentHashMap8Test exte
1008		public void testSearchValuesSequentially() {
1009		ConcurrentHashMap<Long, Long> m = longMap();
1010		Long r;
1011	<	r = m.searchValuesSequentially((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.searchValuesSequentially((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
#	Line 1002 | Line 1023 | public class ConcurrentHashMap8Test exte
1023		public void testSearchSequentially() {
1024		ConcurrentHashMap<Long, Long> m = longMap();
1025		Long r;
1026	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1026	>	r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1027		assertEquals((long)r, (long)(SIZE/2));
1028	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() < 0L ? x : null);
1028	>	r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() < 0L ? x : null);
1029		assertNull(r);
1030		}
1031
#	Line 1015 | Line 1036 | public class ConcurrentHashMap8Test exte
1036		public void testSearchEntriesSequentially() {
1037		ConcurrentHashMap<Long, Long> m = longMap();
1038		Long r;
1039	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1039	>	r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1040		assertEquals((long)r, (long)(SIZE/2));
1041	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1041	>	r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1042		assertNull(r);
1043		}
1044
#	Line 1028 | Line 1049 | public class ConcurrentHashMap8Test exte
1049		public void testSearchKeysInParallel() {
1050		ConcurrentHashMap<Long, Long> m = longMap();
1051		Long r;
1052	<	r = m.searchKeysInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1052	>	r = m.searchKeys(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1053		assertEquals((long)r, (long)(SIZE/2));
1054	<	r = m.searchKeysInParallel((Long x) -> x.longValue() < 0L ? x : null);
1054	>	r = m.searchKeys(1L, (Long x) -> x.longValue() < 0L ? x : null);
1055		assertNull(r);
1056		}
1057
#	Line 1041 | Line 1062 | public class ConcurrentHashMap8Test exte
1062		public void testSearchValuesInParallel() {
1063		ConcurrentHashMap<Long, Long> m = longMap();
1064		Long r;
1065	<	r = m.searchValuesInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1065	>	r = m.searchValues(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1066		assertEquals((long)r, (long)(SIZE/2));
1067	<	r = m.searchValuesInParallel((Long x) -> x.longValue() < 0L ? x : null);
1067	>	r = m.searchValues(1L, (Long x) -> x.longValue() < 0L ? x : null);
1068		assertNull(r);
1069		}
1070
#	Line 1054 | Line 1075 | public class ConcurrentHashMap8Test exte
1075		public void testSearchInParallel() {
1076		ConcurrentHashMap<Long, Long> m = longMap();
1077		Long r;
1078	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1078	>	r = m.search(1L, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1079		assertEquals((long)r, (long)(SIZE/2));
1080	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() < 0L ? x : null);
1080	>	r = m.search(1L, (Long x, Long y) -> x.longValue() < 0L ? x : null);
1081		assertNull(r);
1082		}
1083
#	Line 1067 | Line 1088 | public class ConcurrentHashMap8Test exte
1088		public void testSearchEntriesInParallel() {
1089		ConcurrentHashMap<Long, Long> m = longMap();
1090		Long r;
1091	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1091	>	r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1092		assertEquals((long)r, (long)(SIZE/2));
1093	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1093	>	r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1094		assertNull(r);
1095		}
1096
1076	–	/**
1077	–	* Invoking task versions of bulk methods has same effect as
1078	–	* parallel methods
1079	–	*/
1080	–	public void testForkJoinTasks() {
1081	–	LongAdder adder = new LongAdder();
1082	–	ConcurrentHashMap<Long, Long> m = longMap();
1083	–	ConcurrentHashMap.ForkJoinTasks.forEachKey
1084	–	(m, (Long x) -> adder.add(x.longValue())).invoke();
1085	–	assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
1086	–	adder.reset();
1087	–	ConcurrentHashMap.ForkJoinTasks.forEachValue
1088	–	(m, (Long x) -> adder.add(x.longValue())).invoke();
1089	–	assertEquals(adder.sum(), SIZE * (SIZE - 1));
1090	–	adder.reset();
1091	–	ConcurrentHashMap.ForkJoinTasks.forEach
1092	–	(m, (Long x, Long y) -> adder.add(x.longValue() + y.longValue())).invoke();
1093	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1094	–	adder.reset();
1095	–	ConcurrentHashMap.ForkJoinTasks.forEachEntry
1096	–	(m,
1097	–	(Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue())).invoke();
1098	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1099	–	adder.reset();
1100	–	ConcurrentHashMap.ForkJoinTasks.forEachKey
1101	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1102	–	(Long x) -> adder.add(x.longValue())).invoke();
1103	–	assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
1104	–	adder.reset();
1105	–	ConcurrentHashMap.ForkJoinTasks.forEachValue
1106	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1107	–	(Long x) -> adder.add(x.longValue())).invoke();
1108	–	assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
1109	–	adder.reset();
1110	–	ConcurrentHashMap.ForkJoinTasks.forEach
1111	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
1112	–	(Long x) -> adder.add(x.longValue())).invoke();
1113	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1114	–	adder.reset();
1115	–	ConcurrentHashMap.ForkJoinTasks.forEachEntry
1116	–	(m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
1117	–	(Long x) -> adder.add(x.longValue())).invoke();
1118	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1119	–	adder.reset();
1120	–
1121	–	Long r; long lr; int ir; double dr;
1122	–	r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
1123	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1124	–	assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
1125	–	r = ConcurrentHashMap.ForkJoinTasks.reduceValues
1126	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1127	–	assertEquals((long)r, (long)SIZE * (SIZE - 1));
1128	–	r = ConcurrentHashMap.ForkJoinTasks.reduce
1129	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
1130	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1131	–	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
1132	–	r = ConcurrentHashMap.ForkJoinTasks.reduceEntries
1133	–	(m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
1134	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1135	–	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
1136	–	r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
1137	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1138	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1139	–	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
1140	–	lr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToLong
1141	–	(m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
1142	–	assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
1143	–	ir = ConcurrentHashMap.ForkJoinTasks.reduceKeysToInt
1144	–	(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1145	–	assertEquals(ir, SIZE * (SIZE - 1) / 2);
1146	–	dr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToDouble
1147	–	(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1148	–	assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
1149	–	r = ConcurrentHashMap.ForkJoinTasks.reduceValues
1150	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1151	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1152	–	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
1153	–	lr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToLong
1154	–	(m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
1155	–	assertEquals(lr, (long)SIZE * (SIZE - 1));
1156	–	ir = ConcurrentHashMap.ForkJoinTasks.reduceValuesToInt
1157	–	(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1158	–	assertEquals(ir, SIZE * (SIZE - 1));
1159	–	dr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToDouble
1160	–	(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1161	–	assertEquals(dr, (double)SIZE * (SIZE - 1));
1162	–	r = ConcurrentHashMap.ForkJoinTasks.searchKeys
1163	–	(m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1164	–	assertEquals((long)r, (long)(SIZE/2));
1165	–	r = ConcurrentHashMap.ForkJoinTasks.searchValues
1166	–	(m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1167	–	assertEquals((long)r, (long)(SIZE/2));
1168	–	r = ConcurrentHashMap.ForkJoinTasks.search
1169	–	(m, (Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1170	–	assertEquals((long)r, (long)(SIZE/2));
1171	–	r = ConcurrentHashMap.ForkJoinTasks.searchEntries
1172	–	(m, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null).invoke();
1173	–	assertEquals((long)r, (long)(SIZE/2));
1174	–	}
1097		}

Diff Legend

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