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.4 by jsr166, Fri Mar 22 16:10:19 2013 UTC vs.
Revision 1.25 by jsr166, Fri Feb 27 21:05:11 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.concurrent.ConcurrentHashMap;
21	+	import java.util.concurrent.atomic.LongAdder;
22	+	import java.util.function.BiFunction;
23	+
24	+	import junit.framework.Test;
25	+	import junit.framework.TestSuite;
26
27		public class ConcurrentHashMap8Test extends JSR166TestCase {
28		public static void main(String[] args) {
#	Line 53 | Line 67 | public class ConcurrentHashMap8Test exte
67		}
68
69		/**
70	<	* computeIfAbsent does not replace  if the key is already present
70	>	* computeIfAbsent does not replace if the key is already present
71		*/
72		public void testComputeIfAbsent2() {
73		ConcurrentHashMap map = map5();
#	Line 70 | Line 84 | public class ConcurrentHashMap8Test exte
84		}
85
86		/**
87	<	* computeIfPresent does not replace  if the key is already present
87	>	* computeIfPresent does not replace if the key is already present
88		*/
89		public void testComputeIfPresent() {
90		ConcurrentHashMap map = map5();
#	Line 87 | Line 101 | public class ConcurrentHashMap8Test exte
101		}
102
103		/**
104	<	* compute does not replace  if the function returns null
104	>	* compute does not replace if the function returns null
105		*/
106		public void testCompute() {
107		ConcurrentHashMap map = map5();
#	Line 150 | Line 164 | public class ConcurrentHashMap8Test exte
164		assertTrue(a.isEmpty());
165		for (int i = 0; i < n; i++)
166		a.add(i);
167	<	assertFalse(a.isEmpty());
167	>	assertEquals(n == 0, a.isEmpty());
168		assertEquals(n, a.size());
169		return a;
170		}
#	Line 166 | Line 180 | public class ConcurrentHashMap8Test exte
180		}
181
182		/**
183	+	* replaceAll replaces all matching values.
184	+	*/
185	+	public void testReplaceAll() {
186	+	ConcurrentHashMap<Integer, String> map = map5();
187	+	map.replaceAll((x, y) -> { return x > 3 ? "Z" : y; });
188	+	assertEquals("A", map.get(one));
189	+	assertEquals("B", map.get(two));
190	+	assertEquals("C", map.get(three));
191	+	assertEquals("Z", map.get(four));
192	+	assertEquals("Z", map.get(five));
193	+	}
194	+
195	+	/**
196		* Default-constructed set is empty
197		*/
198		public void testNewKeySet() {
#	Line 174 | Line 201 | public class ConcurrentHashMap8Test exte
201		}
202
203		/**
204	+	* keySet.add adds the key with the established value to the map;
205	+	* remove removes it.
206	+	*/
207	+	public void testKeySetAddRemove() {
208	+	ConcurrentHashMap map = map5();
209	+	Set set1 = map.keySet();
210	+	Set set2 = map.keySet(true);
211	+	set2.add(six);
212	+	assertTrue(((ConcurrentHashMap.KeySetView)set2).getMap() == map);
213	+	assertTrue(((ConcurrentHashMap.KeySetView)set1).getMap() == map);
214	+	assertEquals(set2.size(), map.size());
215	+	assertEquals(set1.size(), map.size());
216	+	assertTrue((Boolean)map.get(six));
217	+	assertTrue(set1.contains(six));
218	+	assertTrue(set2.contains(six));
219	+	set2.remove(six);
220	+	assertNull(map.get(six));
221	+	assertFalse(set1.contains(six));
222	+	assertFalse(set2.contains(six));
223	+	}
224	+
225	+	/**
226		* keySet.addAll adds each element from the given collection
227		*/
228		public void testAddAll() {
229		Set full = populatedSet(3);
230	<	Vector v = new Vector();
231	<	v.add(three);
232	<	v.add(four);
184	<	v.add(five);
185	<	full.addAll(v);
230	>	assertTrue(full.addAll(Arrays.asList(three, four, five)));
231	>	assertEquals(6, full.size());
232	>	assertFalse(full.addAll(Arrays.asList(three, four, five)));
233		assertEquals(6, full.size());
234		}
235
#	Line 192 | Line 239 | public class ConcurrentHashMap8Test exte
239		*/
240		public void testAddAll2() {
241		Set full = populatedSet(3);
242	<	Vector v = new Vector();
243	<	v.add(three);
244	<	v.add(four);
245	<	v.add(one); // will not add this element
199	<	full.addAll(v);
242	>	// "one" is duplicate and will not be added
243	>	assertTrue(full.addAll(Arrays.asList(three, four, one)));
244	>	assertEquals(5, full.size());
245	>	assertFalse(full.addAll(Arrays.asList(three, four, one)));
246		assertEquals(5, full.size());
247		}
248
#	Line 205 | Line 251 | public class ConcurrentHashMap8Test exte
251		*/
252		public void testAdd2() {
253		Set full = populatedSet(3);
254	<	full.add(one);
254	>	assertFalse(full.add(one));
255		assertEquals(3, full.size());
256		}
257
#	Line 214 | Line 260 | public class ConcurrentHashMap8Test exte
260		*/
261		public void testAdd3() {
262		Set full = populatedSet(3);
263	<	full.add(three);
263	>	assertTrue(full.add(three));
264	>	assertTrue(full.contains(three));
265	>	assertFalse(full.add(three));
266		assertTrue(full.contains(three));
267		}
268
269		/**
270	+	* keySet.add throws UnsupportedOperationException if no default
271	+	* mapped value
272	+	*/
273	+	public void testAdd4() {
274	+	Set full = map5().keySet();
275	+	try {
276	+	full.add(three);
277	+	shouldThrow();
278	+	} catch (UnsupportedOperationException success) {}
279	+	}
280	+
281	+	/**
282	+	* keySet.add throws NullPointerException if the specified key is
283	+	* null
284	+	*/
285	+	public void testAdd5() {
286	+	Set full = populatedSet(3);
287	+	try {
288	+	full.add(null);
289	+	shouldThrow();
290	+	} catch (NullPointerException success) {}
291	+	}
292	+
293	+	/**
294	+	* KeySetView.getMappedValue returns the map's mapped value
295	+	*/
296	+	public void testGetMappedValue() {
297	+	ConcurrentHashMap map = map5();
298	+	assertNull(map.keySet().getMappedValue());
299	+	try {
300	+	map.keySet(null);
301	+	shouldThrow();
302	+	} catch (NullPointerException e) {}
303	+	ConcurrentHashMap.KeySetView set = map.keySet(one);
304	+	set.add(one);
305	+	set.add(six);
306	+	set.add(seven);
307	+	assertTrue(set.getMappedValue() == one);
308	+	assertTrue(map.get(one) != one);
309	+	assertTrue(map.get(six) == one);
310	+	assertTrue(map.get(seven) == one);
311	+	}
312	+
313	+	void checkSpliteratorCharacteristics(Spliterator<?> sp,
314	+	int requiredCharacteristics) {
315	+	assertEquals(requiredCharacteristics,
316	+	requiredCharacteristics & sp.characteristics());
317	+	}
318	+
319	+	/**
320	+	* KeySetView.spliterator returns spliterator over the elements in this set
321	+	*/
322	+	public void testKeySetSpliterator() {
323	+	LongAdder adder = new LongAdder();
324	+	ConcurrentHashMap map = map5();
325	+	Set set = map.keySet();
326	+	Spliterator<Integer> sp = set.spliterator();
327	+	checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
328	+	assertEquals(sp.estimateSize(), map.size());
329	+	Spliterator<Integer> sp2 = sp.trySplit();
330	+	sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
331	+	long v = adder.sumThenReset();
332	+	sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
333	+	long v2 = adder.sum();
334	+	assertEquals(v + v2, 15);
335	+	}
336	+
337	+	/**
338		* keyset.clear removes all elements from the set
339		*/
340		public void testClear() {
#	Line 258 | Line 374 | public class ConcurrentHashMap8Test exte
374		* KeySet.containsAll returns true for collections with subset of elements
375		*/
376		public void testContainsAll() {
377	<	Set full = populatedSet(3);
378	<	Vector v = new Vector();
379	<	v.add(one);
380	<	v.add(two);
381	<	assertTrue(full.containsAll(v));
382	<	v.add(six);
267	<	assertFalse(full.containsAll(v));
377	>	Collection full = populatedSet(3);
378	>	assertTrue(full.containsAll(Arrays.asList()));
379	>	assertTrue(full.containsAll(Arrays.asList(one)));
380	>	assertTrue(full.containsAll(Arrays.asList(one, two)));
381	>	assertFalse(full.containsAll(Arrays.asList(one, two, six)));
382	>	assertFalse(full.containsAll(Arrays.asList(six)));
383		}
384
385		/**
386		* KeySet.isEmpty is true when empty, else false
387		*/
388		public void testIsEmpty() {
389	<	Set empty = ConcurrentHashMap.newKeySet();
390	<	Set full = populatedSet(3);
276	<	assertTrue(empty.isEmpty());
277	<	assertFalse(full.isEmpty());
389	>	assertTrue(populatedSet(0).isEmpty());
390	>	assertFalse(populatedSet(3).isEmpty());
391		}
392
393		/**
#	Line 301 | Line 414 | public class ConcurrentHashMap8Test exte
414		assertTrue(it.hasNext());
415		it.next();
416		}
417	<	assertFalse(it.hasNext());
418	<	try {
419	<	it.next();
420	<	shouldThrow();
421	<	} catch (NoSuchElementException success) {}
417	>	assertIteratorExhausted(it);
418	>	}
419	>
420	>	/**
421	>	* iterator of empty collections has no elements
422	>	*/
423	>	public void testEmptyIterator() {
424	>	assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
425	>	assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
426	>	assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
427	>	assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
428		}
429
430		/**
#	Line 339 | Line 458 | public class ConcurrentHashMap8Test exte
458		*/
459		public void testRemoveAll() {
460		Set full = populatedSet(3);
461	<	Vector v = new Vector();
462	<	v.add(one);
463	<	v.add(two);
345	<	full.removeAll(v);
461	>	assertTrue(full.removeAll(Arrays.asList(one, two)));
462	>	assertEquals(1, full.size());
463	>	assertFalse(full.removeAll(Arrays.asList(one, two)));
464		assertEquals(1, full.size());
465		}
466
#	Line 431 | Line 549 | public class ConcurrentHashMap8Test exte
549		Set x = populatedSet(size);
550		Set y = serialClone(x);
551
552	<	assertTrue(x != y);
552	>	assertNotSame(x, y);
553		assertEquals(x.size(), y.size());
436	–	assertEquals(x.toString(), y.toString());
437	–	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
554		assertEquals(x, y);
555		assertEquals(y, x);
556		}
557
442	–
558		static final int SIZE = 10000;
559		static ConcurrentHashMap<Long, Long> longMap;
560
#	Line 467 | Line 582 | public class ConcurrentHashMap8Test exte
582		public void testForEachKeySequentially() {
583		LongAdder adder = new LongAdder();
584		ConcurrentHashMap<Long, Long> m = longMap();
585	<	m.forEachKeySequentially((Long x) -> adder.add(x.longValue()));
585	>	m.forEachKey(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
586		assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
587		}
588
#	Line 477 | Line 592 | public class ConcurrentHashMap8Test exte
592		public void testForEachValueSequentially() {
593		LongAdder adder = new LongAdder();
594		ConcurrentHashMap<Long, Long> m = longMap();
595	<	m.forEachValueSequentially((Long x) -> adder.add(x.longValue()));
595	>	m.forEachValue(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
596		assertEquals(adder.sum(), SIZE * (SIZE - 1));
597		}
598
#	Line 487 | Line 602 | public class ConcurrentHashMap8Test exte
602		public void testForEachSequentially() {
603		LongAdder adder = new LongAdder();
604		ConcurrentHashMap<Long, Long> m = longMap();
605	<	m.forEachSequentially((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
605	>	m.forEach(Long.MAX_VALUE, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
606		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
607		}
608
#	Line 497 | Line 612 | public class ConcurrentHashMap8Test exte
612		public void testForEachEntrySequentially() {
613		LongAdder adder = new LongAdder();
614		ConcurrentHashMap<Long, Long> m = longMap();
615	<	m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
615	>	m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
616		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
617		}
618
#	Line 507 | Line 622 | public class ConcurrentHashMap8Test exte
622		public void testForEachKeyInParallel() {
623		LongAdder adder = new LongAdder();
624		ConcurrentHashMap<Long, Long> m = longMap();
625	<	m.forEachKeyInParallel((Long x) -> adder.add(x.longValue()));
625	>	m.forEachKey(1L, (Long x) -> adder.add(x.longValue()));
626		assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
627		}
628
#	Line 517 | Line 632 | public class ConcurrentHashMap8Test exte
632		public void testForEachValueInParallel() {
633		LongAdder adder = new LongAdder();
634		ConcurrentHashMap<Long, Long> m = longMap();
635	<	m.forEachValueInParallel((Long x) -> adder.add(x.longValue()));
635	>	m.forEachValue(1L, (Long x) -> adder.add(x.longValue()));
636		assertEquals(adder.sum(), SIZE * (SIZE - 1));
637		}
638
#	Line 527 | Line 642 | public class ConcurrentHashMap8Test exte
642		public void testForEachInParallel() {
643		LongAdder adder = new LongAdder();
644		ConcurrentHashMap<Long, Long> m = longMap();
645	<	m.forEachInParallel((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
645	>	m.forEach(1L, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
646		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
647		}
648
#	Line 537 | Line 652 | public class ConcurrentHashMap8Test exte
652		public void testForEachEntryInParallel() {
653		LongAdder adder = new LongAdder();
654		ConcurrentHashMap<Long, Long> m = longMap();
655	<	m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
655	>	m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
656		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
657		}
658
#	Line 548 | Line 663 | public class ConcurrentHashMap8Test exte
663		public void testMappedForEachKeySequentially() {
664		LongAdder adder = new LongAdder();
665		ConcurrentHashMap<Long, Long> m = longMap();
666	<	m.forEachKeySequentially((Long x) -> Long.valueOf(4 * x.longValue()),
666	>	m.forEachKey(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
667		(Long x) -> adder.add(x.longValue()));
668		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
669		}
#	Line 560 | Line 675 | public class ConcurrentHashMap8Test exte
675		public void testMappedForEachValueSequentially() {
676		LongAdder adder = new LongAdder();
677		ConcurrentHashMap<Long, Long> m = longMap();
678	<	m.forEachValueSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
678	>	m.forEachValue(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
679		(Long x) -> adder.add(x.longValue()));
680		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
681		}
#	Line 572 | Line 687 | public class ConcurrentHashMap8Test exte
687		public void testMappedForEachSequentially() {
688		LongAdder adder = new LongAdder();
689		ConcurrentHashMap<Long, Long> m = longMap();
690	<	m.forEachSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
690	>	m.forEach(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
691		(Long x) -> adder.add(x.longValue()));
692		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
693		}
#	Line 584 | Line 699 | public class ConcurrentHashMap8Test exte
699		public void testMappedForEachEntrySequentially() {
700		LongAdder adder = new LongAdder();
701		ConcurrentHashMap<Long, Long> m = longMap();
702	<	m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
702	>	m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
703		(Long x) -> adder.add(x.longValue()));
704		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
705		}
#	Line 596 | Line 711 | public class ConcurrentHashMap8Test exte
711		public void testMappedForEachKeyInParallel() {
712		LongAdder adder = new LongAdder();
713		ConcurrentHashMap<Long, Long> m = longMap();
714	<	m.forEachKeyInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
714	>	m.forEachKey(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
715		(Long x) -> adder.add(x.longValue()));
716		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
717		}
#	Line 608 | Line 723 | public class ConcurrentHashMap8Test exte
723		public void testMappedForEachValueInParallel() {
724		LongAdder adder = new LongAdder();
725		ConcurrentHashMap<Long, Long> m = longMap();
726	<	m.forEachValueInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
726	>	m.forEachValue(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
727		(Long x) -> adder.add(x.longValue()));
728		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
729		}
#	Line 620 | Line 735 | public class ConcurrentHashMap8Test exte
735		public void testMappedForEachInParallel() {
736		LongAdder adder = new LongAdder();
737		ConcurrentHashMap<Long, Long> m = longMap();
738	<	m.forEachInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
738	>	m.forEach(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
739		(Long x) -> adder.add(x.longValue()));
740		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
741		}
#	Line 632 | Line 747 | public class ConcurrentHashMap8Test exte
747		public void testMappedForEachEntryInParallel() {
748		LongAdder adder = new LongAdder();
749		ConcurrentHashMap<Long, Long> m = longMap();
750	<	m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
750	>	m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
751		(Long x) -> adder.add(x.longValue()));
752		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
753		}
754
640	–
755		/**
756		* reduceKeysSequentially accumulates across all keys,
757		*/
758		public void testReduceKeysSequentially() {
759		ConcurrentHashMap<Long, Long> m = longMap();
760		Long r;
761	<	r = m.reduceKeysSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
761	>	r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
762		assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
763		}
764
#	Line 654 | Line 768 | public class ConcurrentHashMap8Test exte
768		public void testReduceValuesSequentially() {
769		ConcurrentHashMap<Long, Long> m = longMap();
770		Long r;
771	<	r = m.reduceKeysSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
771	>	r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
772		assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
773		}
774
661	–
775		/**
776		* reduceEntriesSequentially accumulates across all entries
777		*/
778		public void testReduceEntriesSequentially() {
779		ConcurrentHashMap<Long, Long> m = longMap();
780		Map.Entry<Long,Long> r;
781	<	r = m.reduceEntriesSequentially(new AddKeys());
781	>	r = m.reduceEntries(Long.MAX_VALUE, new AddKeys());
782		assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
783		}
784
#	Line 675 | Line 788 | public class ConcurrentHashMap8Test exte
788		public void testReduceKeysInParallel() {
789		ConcurrentHashMap<Long, Long> m = longMap();
790		Long r;
791	<	r = m.reduceKeysInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
791	>	r = m.reduceKeys(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
792		assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
793		}
794
#	Line 685 | Line 798 | public class ConcurrentHashMap8Test exte
798		public void testReduceValuesInParallel() {
799		ConcurrentHashMap<Long, Long> m = longMap();
800		Long r;
801	<	r = m.reduceValuesInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
801	>	r = m.reduceValues(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
802		assertEquals((long)r, (long)SIZE * (SIZE - 1));
803		}
804
#	Line 695 | Line 808 | public class ConcurrentHashMap8Test exte
808		public void testReduceEntriesInParallel() {
809		ConcurrentHashMap<Long, Long> m = longMap();
810		Map.Entry<Long,Long> r;
811	<	r = m.reduceEntriesInParallel(new AddKeys());
811	>	r = m.reduceEntries(1L, new AddKeys());
812		assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
813		}
814
815	<	/*
815	>	/**
816		* Mapped reduceKeysSequentially accumulates mapped keys
817		*/
818		public void testMapReduceKeysSequentially() {
819		ConcurrentHashMap<Long, Long> m = longMap();
820	<	Long r = m.reduceKeysSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
820	>	Long r = m.reduceKeys(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
821		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
822		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
823		}
824
825	<	/*
825	>	/**
826		* Mapped reduceValuesSequentially accumulates mapped values
827		*/
828		public void testMapReduceValuesSequentially() {
829		ConcurrentHashMap<Long, Long> m = longMap();
830	<	Long r = m.reduceValuesSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
830	>	Long r = m.reduceValues(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
831		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
832		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
833		}
#	Line 724 | Line 837 | public class ConcurrentHashMap8Test exte
837		*/
838		public void testMappedReduceSequentially() {
839		ConcurrentHashMap<Long, Long> m = longMap();
840	<	Long r = m.reduceSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
840	>	Long r = m.reduce(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
841		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
842
843		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
844		}
845
846	<	/*
846	>	/**
847		* Mapped reduceKeysInParallel, accumulates mapped keys
848		*/
849		public void testMapReduceKeysInParallel() {
850		ConcurrentHashMap<Long, Long> m = longMap();
851	<	Long r = m.reduceKeysInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
851	>	Long r = m.reduceKeys(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
852		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
853		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
854		}
855
856	<	/*
856	>	/**
857		* Mapped reduceValuesInParallel accumulates mapped values
858		*/
859		public void testMapReduceValuesInParallel() {
860		ConcurrentHashMap<Long, Long> m = longMap();
861	<	Long r = m.reduceValuesInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
861	>	Long r = m.reduceValues(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
862		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
863		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
864		}
#	Line 756 | Line 869 | public class ConcurrentHashMap8Test exte
869		public void testMappedReduceInParallel() {
870		ConcurrentHashMap<Long, Long> m = longMap();
871		Long r;
872	<	r = m.reduceInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
872	>	r = m.reduce(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
873		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
874		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
875		}
876
877	<
765	<	/*
877	>	/**
878		* reduceKeysToLongSequentially accumulates mapped keys
879		*/
880		public void testReduceKeysToLongSequentially() {
881		ConcurrentHashMap<Long, Long> m = longMap();
882	<	long lr = m.reduceKeysToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
882	>	long lr = m.reduceKeysToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
883		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
884		}
885
886	<	/*
886	>	/**
887		* reduceKeysToIntSequentially accumulates mapped keys
888		*/
889		public void testReduceKeysToIntSequentially() {
890		ConcurrentHashMap<Long, Long> m = longMap();
891	<	int ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
892	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
891	>	int ir = m.reduceKeysToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
892	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
893		}
894
895	<	/*
895	>	/**
896		* reduceKeysToDoubleSequentially accumulates mapped keys
897		*/
898		public void testReduceKeysToDoubleSequentially() {
899		ConcurrentHashMap<Long, Long> m = longMap();
900	<	double dr = m.reduceKeysToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
900	>	double dr = m.reduceKeysToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
901		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
902		}
903
904	<	/*
904	>	/**
905		* reduceValuesToLongSequentially accumulates mapped values
906		*/
907		public void testReduceValuesToLongSequentially() {
908		ConcurrentHashMap<Long, Long> m = longMap();
909	<	long lr = m.reduceValuesToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
909	>	long lr = m.reduceValuesToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
910		assertEquals(lr, (long)SIZE * (SIZE - 1));
911		}
912
913	<	/*
913	>	/**
914		* reduceValuesToIntSequentially accumulates mapped values
915		*/
916		public void testReduceValuesToIntSequentially() {
917		ConcurrentHashMap<Long, Long> m = longMap();
918	<	int ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
919	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
918	>	int ir = m.reduceValuesToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
919	>	assertEquals(ir, SIZE * (SIZE - 1));
920		}
921
922	<	/*
922	>	/**
923		* reduceValuesToDoubleSequentially accumulates mapped values
924		*/
925		public void testReduceValuesToDoubleSequentially() {
926		ConcurrentHashMap<Long, Long> m = longMap();
927	<	double dr = m.reduceValuesToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
927	>	double dr = m.reduceValuesToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
928		assertEquals(dr, (double)SIZE * (SIZE - 1));
929		}
930
931	<	/*
931	>	/**
932		* reduceKeysToLongInParallel accumulates mapped keys
933		*/
934		public void testReduceKeysToLongInParallel() {
935		ConcurrentHashMap<Long, Long> m = longMap();
936	<	long lr = m.reduceKeysToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
936	>	long lr = m.reduceKeysToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
937		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
938		}
939
940	<	/*
940	>	/**
941		* reduceKeysToIntInParallel accumulates mapped keys
942		*/
943		public void testReduceKeysToIntInParallel() {
944		ConcurrentHashMap<Long, Long> m = longMap();
945	<	int ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
946	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
945	>	int ir = m.reduceKeysToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
946	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
947		}
948
949	<	/*
949	>	/**
950		* reduceKeysToDoubleInParallel accumulates mapped values
951		*/
952		public void testReduceKeysToDoubleInParallel() {
953		ConcurrentHashMap<Long, Long> m = longMap();
954	<	double dr = m.reduceKeysToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
954	>	double dr = m.reduceKeysToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
955		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
956		}
957
958	<	/*
958	>	/**
959		* reduceValuesToLongInParallel accumulates mapped values
960		*/
961		public void testReduceValuesToLongInParallel() {
962		ConcurrentHashMap<Long, Long> m = longMap();
963	<	long lr = m.reduceValuesToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
963	>	long lr = m.reduceValuesToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
964		assertEquals(lr, (long)SIZE * (SIZE - 1));
965		}
966
967	<	/*
967	>	/**
968		* reduceValuesToIntInParallel accumulates mapped values
969		*/
970		public void testReduceValuesToIntInParallel() {
971		ConcurrentHashMap<Long, Long> m = longMap();
972	<	int ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
973	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
972	>	int ir = m.reduceValuesToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
973	>	assertEquals(ir, SIZE * (SIZE - 1));
974		}
975
976	<	/*
976	>	/**
977		* reduceValuesToDoubleInParallel accumulates mapped values
978		*/
979		public void testReduceValuesToDoubleInParallel() {
980		ConcurrentHashMap<Long, Long> m = longMap();
981	<	double dr = m.reduceValuesToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
981	>	double dr = m.reduceValuesToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
982		assertEquals(dr, (double)SIZE * (SIZE - 1));
983		}
984
#	Line 877 | Line 989 | public class ConcurrentHashMap8Test exte
989		public void testSearchKeysSequentially() {
990		ConcurrentHashMap<Long, Long> m = longMap();
991		Long r;
992	<	r = m.searchKeysSequentially((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
992	>	r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
993		assertEquals((long)r, (long)(SIZE/2));
994	<	r = m.searchKeysSequentially((Long x) -> x.longValue() < 0L ? x : null);
994	>	r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
995		assertNull(r);
996		}
997
#	Line 890 | Line 1002 | public class ConcurrentHashMap8Test exte
1002		public void testSearchValuesSequentially() {
1003		ConcurrentHashMap<Long, Long> m = longMap();
1004		Long r;
1005	<	r = m.searchValuesSequentially((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1005	>	r = m.searchValues(Long.MAX_VALUE,
1006	>	(Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
1007		assertEquals((long)r, (long)(SIZE/2));
1008	<	r = m.searchValuesSequentially((Long x) -> x.longValue() < 0L ? x : null);
1008	>	r = m.searchValues(Long.MAX_VALUE,
1009	>	(Long x) -> (x.longValue() < 0L) ? x : null);
1010		assertNull(r);
1011		}
1012
#	Line 903 | Line 1017 | public class ConcurrentHashMap8Test exte
1017		public void testSearchSequentially() {
1018		ConcurrentHashMap<Long, Long> m = longMap();
1019		Long r;
1020	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1020	>	r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1021		assertEquals((long)r, (long)(SIZE/2));
1022	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() < 0L ? x : null);
1022	>	r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() < 0L ? x : null);
1023		assertNull(r);
1024		}
1025
#	Line 916 | Line 1030 | public class ConcurrentHashMap8Test exte
1030		public void testSearchEntriesSequentially() {
1031		ConcurrentHashMap<Long, Long> m = longMap();
1032		Long r;
1033	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1033	>	r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1034		assertEquals((long)r, (long)(SIZE/2));
1035	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1035	>	r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1036		assertNull(r);
1037		}
1038
#	Line 929 | Line 1043 | public class ConcurrentHashMap8Test exte
1043		public void testSearchKeysInParallel() {
1044		ConcurrentHashMap<Long, Long> m = longMap();
1045		Long r;
1046	<	r = m.searchKeysInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1046	>	r = m.searchKeys(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1047		assertEquals((long)r, (long)(SIZE/2));
1048	<	r = m.searchKeysInParallel((Long x) -> x.longValue() < 0L ? x : null);
1048	>	r = m.searchKeys(1L, (Long x) -> x.longValue() < 0L ? x : null);
1049		assertNull(r);
1050		}
1051
#	Line 942 | Line 1056 | public class ConcurrentHashMap8Test exte
1056		public void testSearchValuesInParallel() {
1057		ConcurrentHashMap<Long, Long> m = longMap();
1058		Long r;
1059	<	r = m.searchValuesInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1059	>	r = m.searchValues(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1060		assertEquals((long)r, (long)(SIZE/2));
1061	<	r = m.searchValuesInParallel((Long x) -> x.longValue() < 0L ? x : null);
1061	>	r = m.searchValues(1L, (Long x) -> x.longValue() < 0L ? x : null);
1062		assertNull(r);
1063		}
1064
#	Line 955 | Line 1069 | public class ConcurrentHashMap8Test exte
1069		public void testSearchInParallel() {
1070		ConcurrentHashMap<Long, Long> m = longMap();
1071		Long r;
1072	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1072	>	r = m.search(1L, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1073		assertEquals((long)r, (long)(SIZE/2));
1074	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() < 0L ? x : null);
1074	>	r = m.search(1L, (Long x, Long y) -> x.longValue() < 0L ? x : null);
1075		assertNull(r);
1076		}
1077
#	Line 968 | Line 1082 | public class ConcurrentHashMap8Test exte
1082		public void testSearchEntriesInParallel() {
1083		ConcurrentHashMap<Long, Long> m = longMap();
1084		Long r;
1085	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1085	>	r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1086		assertEquals((long)r, (long)(SIZE/2));
1087	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1087	>	r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1088		assertNull(r);
1089		}
1090
977	–	/**
978	–	* Invoking task versions of bulk methods has same effect as
979	–	* parallel methods
980	–	*/
981	–	public void testForkJoinTasks() {
982	–	LongAdder adder = new LongAdder();
983	–	ConcurrentHashMap<Long, Long> m = longMap();
984	–	ConcurrentHashMap.ForkJoinTasks.forEachKey
985	–	(m, (Long x) -> adder.add(x.longValue())).invoke();
986	–	assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
987	–	adder.reset();
988	–	ConcurrentHashMap.ForkJoinTasks.forEachValue
989	–	(m, (Long x) -> adder.add(x.longValue())).invoke();
990	–	assertEquals(adder.sum(), SIZE * (SIZE - 1));
991	–	adder.reset();
992	–	ConcurrentHashMap.ForkJoinTasks.forEach
993	–	(m, (Long x, Long y) -> adder.add(x.longValue() + y.longValue())).invoke();
994	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
995	–	adder.reset();
996	–	ConcurrentHashMap.ForkJoinTasks.forEachEntry
997	–	(m,
998	–	(Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue())).invoke();
999	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1000	–	adder.reset();
1001	–	ConcurrentHashMap.ForkJoinTasks.forEachKey
1002	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1003	–	(Long x) -> adder.add(x.longValue())).invoke();
1004	–	assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
1005	–	adder.reset();
1006	–	ConcurrentHashMap.ForkJoinTasks.forEachValue
1007	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1008	–	(Long x) -> adder.add(x.longValue())).invoke();
1009	–	assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
1010	–	adder.reset();
1011	–	ConcurrentHashMap.ForkJoinTasks.forEach
1012	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
1013	–	(Long x) -> adder.add(x.longValue())).invoke();
1014	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1015	–	adder.reset();
1016	–	ConcurrentHashMap.ForkJoinTasks.forEachEntry
1017	–	(m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
1018	–	(Long x) -> adder.add(x.longValue())).invoke();
1019	–	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1020	–	adder.reset();
1021	–
1022	–	Long r; long lr; int ir; double dr;
1023	–	r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
1024	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1025	–	assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
1026	–	r = ConcurrentHashMap.ForkJoinTasks.reduceValues
1027	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1028	–	assertEquals((long)r, (long)SIZE * (SIZE - 1));
1029	–	r = ConcurrentHashMap.ForkJoinTasks.reduce
1030	–	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
1031	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1032	–	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
1033	–	r = ConcurrentHashMap.ForkJoinTasks.reduceEntries
1034	–	(m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
1035	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1036	–	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
1037	–	r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
1038	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1039	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1040	–	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
1041	–	lr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToLong
1042	–	(m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
1043	–	assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
1044	–	ir = ConcurrentHashMap.ForkJoinTasks.reduceKeysToInt
1045	–	(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1046	–	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
1047	–	dr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToDouble
1048	–	(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1049	–	assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
1050	–	r = ConcurrentHashMap.ForkJoinTasks.reduceValues
1051	–	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
1052	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1053	–	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
1054	–	lr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToLong
1055	–	(m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
1056	–	assertEquals(lr, (long)SIZE * (SIZE - 1));
1057	–	ir = ConcurrentHashMap.ForkJoinTasks.reduceValuesToInt
1058	–	(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1059	–	assertEquals(ir, (int)SIZE * (SIZE - 1));
1060	–	dr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToDouble
1061	–	(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1062	–	assertEquals(dr, (double)SIZE * (SIZE - 1));
1063	–	r = ConcurrentHashMap.ForkJoinTasks.searchKeys
1064	–	(m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1065	–	assertEquals((long)r, (long)(SIZE/2));
1066	–	r = ConcurrentHashMap.ForkJoinTasks.searchValues
1067	–	(m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1068	–	assertEquals((long)r, (long)(SIZE/2));
1069	–	r = ConcurrentHashMap.ForkJoinTasks.search
1070	–	(m, (Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1071	–	assertEquals((long)r, (long)(SIZE/2));
1072	–	r = ConcurrentHashMap.ForkJoinTasks.searchEntries
1073	–	(m, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null).invoke();
1074	–	assertEquals((long)r, (long)(SIZE/2));
1075	–	}
1091		}

Diff Legend

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