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.2 by dl, Fri Mar 22 00:24:35 2013 UTC vs.
Revision 1.31 by jsr166, Wed Aug 24 22:22:39 2016 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.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.Iterator;
15	>	import java.util.Map;
16	>	import java.util.NoSuchElementException;
17	>	import java.util.Set;
18	>	import java.util.Spliterator;
19		import java.util.concurrent.ConcurrentHashMap;
20	+	import java.util.concurrent.atomic.LongAdder;
21	+	import java.util.function.BiFunction;
22	+
23	+	import junit.framework.Test;
24	+	import junit.framework.TestSuite;
25
26		public class ConcurrentHashMap8Test extends JSR166TestCase {
27		public static void main(String[] args) {
28	<	junit.textui.TestRunner.run(suite());
28	>	main(suite(), args);
29		}
30		public static Test suite() {
31		return new TestSuite(ConcurrentHashMap8Test.class);
#	Line 34 | Line 48 | public class ConcurrentHashMap8Test exte
48		}
49
50		/**
51	+	* getOrDefault returns value if present, else default
52	+	*/
53	+	public void testGetOrDefault() {
54	+	ConcurrentHashMap map = map5();
55	+	assertEquals(map.getOrDefault(one, "Z"), "A");
56	+	assertEquals(map.getOrDefault(six, "Z"), "Z");
57	+	}
58	+
59	+	/**
60		* computeIfAbsent adds when the given key is not present
61		*/
62		public void testComputeIfAbsent() {
#	Line 43 | Line 66 | public class ConcurrentHashMap8Test exte
66		}
67
68		/**
69	<	* computeIfAbsent does not replace  if the key is already present
69	>	* computeIfAbsent does not replace if the key is already present
70		*/
71		public void testComputeIfAbsent2() {
72		ConcurrentHashMap map = map5();
#	Line 58 | Line 81 | public class ConcurrentHashMap8Test exte
81		map.computeIfAbsent(six, (x) -> null);
82		assertFalse(map.containsKey(six));
83		}
84	<
84	>
85		/**
86	<	* computeIfPresent does not replace  if the key is already present
86	>	* computeIfPresent does not replace if the key is already present
87		*/
88		public void testComputeIfPresent() {
89		ConcurrentHashMap map = map5();
#	Line 77 | Line 100 | public class ConcurrentHashMap8Test exte
100		}
101
102		/**
103	<	* compute does not replace  if the function returns null
103	>	* compute does not replace if the function returns null
104		*/
105		public void testCompute() {
106		ConcurrentHashMap map = map5();
#	Line 135 | Line 158 | public class ConcurrentHashMap8Test exte
158		assertFalse(map.containsKey(one));
159		}
160
161	+	static Set<Integer> populatedSet(int n) {
162	+	Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
163	+	assertTrue(a.isEmpty());
164	+	for (int i = 0; i < n; i++)
165	+	assertTrue(a.add(i));
166	+	assertEquals(n == 0, a.isEmpty());
167	+	assertEquals(n, a.size());
168	+	return a;
169	+	}
170	+
171	+	static Set populatedSet(Integer[] elements) {
172	+	Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
173	+	assertTrue(a.isEmpty());
174	+	for (int i = 0; i < elements.length; i++)
175	+	assertTrue(a.add(elements[i]));
176	+	assertFalse(a.isEmpty());
177	+	assertEquals(elements.length, a.size());
178	+	return a;
179	+	}
180	+
181	+	/**
182	+	* replaceAll replaces all matching values.
183	+	*/
184	+	public void testReplaceAll() {
185	+	ConcurrentHashMap<Integer, String> map = map5();
186	+	map.replaceAll((x, y) -> { return x > 3 ? "Z" : y; });
187	+	assertEquals("A", map.get(one));
188	+	assertEquals("B", map.get(two));
189	+	assertEquals("C", map.get(three));
190	+	assertEquals("Z", map.get(four));
191	+	assertEquals("Z", map.get(five));
192	+	}
193	+
194	+	/**
195	+	* Default-constructed set is empty
196	+	*/
197	+	public void testNewKeySet() {
198	+	Set a = ConcurrentHashMap.newKeySet();
199	+	assertTrue(a.isEmpty());
200	+	}
201	+
202	+	/**
203	+	* keySet.add adds the key with the established value to the map;
204	+	* remove removes it.
205	+	*/
206	+	public void testKeySetAddRemove() {
207	+	ConcurrentHashMap map = map5();
208	+	Set set1 = map.keySet();
209	+	Set set2 = map.keySet(true);
210	+	set2.add(six);
211	+	assertTrue(((ConcurrentHashMap.KeySetView)set2).getMap() == map);
212	+	assertTrue(((ConcurrentHashMap.KeySetView)set1).getMap() == map);
213	+	assertEquals(set2.size(), map.size());
214	+	assertEquals(set1.size(), map.size());
215	+	assertTrue((Boolean)map.get(six));
216	+	assertTrue(set1.contains(six));
217	+	assertTrue(set2.contains(six));
218	+	set2.remove(six);
219	+	assertNull(map.get(six));
220	+	assertFalse(set1.contains(six));
221	+	assertFalse(set2.contains(six));
222	+	}
223	+
224	+	/**
225	+	* keySet.addAll adds each element from the given collection
226	+	*/
227	+	public void testAddAll() {
228	+	Set full = populatedSet(3);
229	+	assertTrue(full.addAll(Arrays.asList(three, four, five)));
230	+	assertEquals(6, full.size());
231	+	assertFalse(full.addAll(Arrays.asList(three, four, five)));
232	+	assertEquals(6, full.size());
233	+	}
234	+
235	+	/**
236	+	* keySet.addAll adds each element from the given collection that did not
237	+	* already exist in the set
238	+	*/
239	+	public void testAddAll2() {
240	+	Set full = populatedSet(3);
241	+	// "one" is duplicate and will not be added
242	+	assertTrue(full.addAll(Arrays.asList(three, four, one)));
243	+	assertEquals(5, full.size());
244	+	assertFalse(full.addAll(Arrays.asList(three, four, one)));
245	+	assertEquals(5, full.size());
246	+	}
247	+
248	+	/**
249	+	* keySet.add will not add the element if it already exists in the set
250	+	*/
251	+	public void testAdd2() {
252	+	Set full = populatedSet(3);
253	+	assertFalse(full.add(one));
254	+	assertEquals(3, full.size());
255	+	}
256	+
257	+	/**
258	+	* keySet.add adds the element when it does not exist in the set
259	+	*/
260	+	public void testAdd3() {
261	+	Set full = populatedSet(3);
262	+	assertTrue(full.add(three));
263	+	assertTrue(full.contains(three));
264	+	assertFalse(full.add(three));
265	+	assertTrue(full.contains(three));
266	+	}
267	+
268	+	/**
269	+	* keySet.add throws UnsupportedOperationException if no default
270	+	* mapped value
271	+	*/
272	+	public void testAdd4() {
273	+	Set full = map5().keySet();
274	+	try {
275	+	full.add(three);
276	+	shouldThrow();
277	+	} catch (UnsupportedOperationException success) {}
278	+	}
279	+
280	+	/**
281	+	* keySet.add throws NullPointerException if the specified key is
282	+	* null
283	+	*/
284	+	public void testAdd5() {
285	+	Set full = populatedSet(3);
286	+	try {
287	+	full.add(null);
288	+	shouldThrow();
289	+	} catch (NullPointerException success) {}
290	+	}
291	+
292	+	/**
293	+	* KeySetView.getMappedValue returns the map's mapped value
294	+	*/
295	+	public void testGetMappedValue() {
296	+	ConcurrentHashMap map = map5();
297	+	assertNull(map.keySet().getMappedValue());
298	+	try {
299	+	map.keySet(null);
300	+	shouldThrow();
301	+	} catch (NullPointerException success) {}
302	+	ConcurrentHashMap.KeySetView set = map.keySet(one);
303	+	assertFalse(set.add(one));
304	+	assertTrue(set.add(six));
305	+	assertTrue(set.add(seven));
306	+	assertTrue(set.getMappedValue() == one);
307	+	assertTrue(map.get(one) != one);
308	+	assertTrue(map.get(six) == one);
309	+	assertTrue(map.get(seven) == one);
310	+	}
311	+
312	+	void checkSpliteratorCharacteristics(Spliterator<?> sp,
313	+	int requiredCharacteristics) {
314	+	assertEquals(requiredCharacteristics,
315	+	requiredCharacteristics & sp.characteristics());
316	+	}
317	+
318	+	/**
319	+	* KeySetView.spliterator returns spliterator over the elements in this set
320	+	*/
321	+	public void testKeySetSpliterator() {
322	+	LongAdder adder = new LongAdder();
323	+	ConcurrentHashMap map = map5();
324	+	Set set = map.keySet();
325	+	Spliterator<Integer> sp = set.spliterator();
326	+	checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
327	+	assertEquals(sp.estimateSize(), map.size());
328	+	Spliterator<Integer> sp2 = sp.trySplit();
329	+	sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
330	+	long v = adder.sumThenReset();
331	+	sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
332	+	long v2 = adder.sum();
333	+	assertEquals(v + v2, 15);
334	+	}
335	+
336	+	/**
337	+	* keyset.clear removes all elements from the set
338	+	*/
339	+	public void testClear() {
340	+	Set full = populatedSet(3);
341	+	full.clear();
342	+	assertEquals(0, full.size());
343	+	}
344	+
345	+	/**
346	+	* keyset.contains returns true for added elements
347	+	*/
348	+	public void testContains() {
349	+	Set full = populatedSet(3);
350	+	assertTrue(full.contains(one));
351	+	assertFalse(full.contains(five));
352	+	}
353	+
354	+	/**
355	+	* KeySets with equal elements are equal
356	+	*/
357	+	public void testEquals() {
358	+	Set a = populatedSet(3);
359	+	Set b = populatedSet(3);
360	+	assertTrue(a.equals(b));
361	+	assertTrue(b.equals(a));
362	+	assertEquals(a.hashCode(), b.hashCode());
363	+	a.add(m1);
364	+	assertFalse(a.equals(b));
365	+	assertFalse(b.equals(a));
366	+	b.add(m1);
367	+	assertTrue(a.equals(b));
368	+	assertTrue(b.equals(a));
369	+	assertEquals(a.hashCode(), b.hashCode());
370	+	}
371	+
372	+	/**
373	+	* KeySet.containsAll returns true for collections with subset of elements
374	+	*/
375	+	public void testContainsAll() {
376	+	Collection full = populatedSet(3);
377	+	assertTrue(full.containsAll(Arrays.asList()));
378	+	assertTrue(full.containsAll(Arrays.asList(one)));
379	+	assertTrue(full.containsAll(Arrays.asList(one, two)));
380	+	assertFalse(full.containsAll(Arrays.asList(one, two, six)));
381	+	assertFalse(full.containsAll(Arrays.asList(six)));
382	+	}
383	+
384	+	/**
385	+	* KeySet.isEmpty is true when empty, else false
386	+	*/
387	+	public void testIsEmpty() {
388	+	assertTrue(populatedSet(0).isEmpty());
389	+	assertFalse(populatedSet(3).isEmpty());
390	+	}
391	+
392	+	/**
393	+	* KeySet.iterator() returns an iterator containing the elements of the
394	+	* set
395	+	*/
396	+	public void testIterator() {
397	+	Collection empty = ConcurrentHashMap.newKeySet();
398	+	int size = 20;
399	+	assertFalse(empty.iterator().hasNext());
400	+	try {
401	+	empty.iterator().next();
402	+	shouldThrow();
403	+	} catch (NoSuchElementException success) {}
404	+
405	+	Integer[] elements = new Integer[size];
406	+	for (int i = 0; i < size; i++)
407	+	elements[i] = i;
408	+	shuffle(elements);
409	+	Collection<Integer> full = populatedSet(elements);
410	+
411	+	Iterator it = full.iterator();
412	+	for (int j = 0; j < size; j++) {
413	+	assertTrue(it.hasNext());
414	+	it.next();
415	+	}
416	+	assertIteratorExhausted(it);
417	+	}
418	+
419	+	/**
420	+	* iterator of empty collections has no elements
421	+	*/
422	+	public void testEmptyIterator() {
423	+	assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
424	+	assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
425	+	assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
426	+	assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
427	+	}
428	+
429	+	/**
430	+	* KeySet.iterator.remove removes current element
431	+	*/
432	+	public void testIteratorRemove() {
433	+	Set q = populatedSet(3);
434	+	Iterator it = q.iterator();
435	+	Object removed = it.next();
436	+	it.remove();
437	+
438	+	it = q.iterator();
439	+	assertFalse(it.next().equals(removed));
440	+	assertFalse(it.next().equals(removed));
441	+	assertFalse(it.hasNext());
442	+	}
443	+
444	+	/**
445	+	* KeySet.toString holds toString of elements
446	+	*/
447	+	public void testToString() {
448	+	assertEquals("[]", ConcurrentHashMap.newKeySet().toString());
449	+	Set full = populatedSet(3);
450	+	String s = full.toString();
451	+	for (int i = 0; i < 3; ++i)
452	+	assertTrue(s.contains(String.valueOf(i)));
453	+	}
454	+
455	+	/**
456	+	* KeySet.removeAll removes all elements from the given collection
457	+	*/
458	+	public void testRemoveAll() {
459	+	Set full = populatedSet(3);
460	+	assertTrue(full.removeAll(Arrays.asList(one, two)));
461	+	assertEquals(1, full.size());
462	+	assertFalse(full.removeAll(Arrays.asList(one, two)));
463	+	assertEquals(1, full.size());
464	+	}
465	+
466	+	/**
467	+	* KeySet.remove removes an element
468	+	*/
469	+	public void testRemove() {
470	+	Set full = populatedSet(3);
471	+	full.remove(one);
472	+	assertFalse(full.contains(one));
473	+	assertEquals(2, full.size());
474	+	}
475	+
476	+	/**
477	+	* keySet.size returns the number of elements
478	+	*/
479	+	public void testSize() {
480	+	Set empty = ConcurrentHashMap.newKeySet();
481	+	Set full = populatedSet(3);
482	+	assertEquals(3, full.size());
483	+	assertEquals(0, empty.size());
484	+	}
485	+
486	+	/**
487	+	* KeySet.toArray() returns an Object array containing all elements from
488	+	* the set
489	+	*/
490	+	public void testToArray() {
491	+	Object[] a = ConcurrentHashMap.newKeySet().toArray();
492	+	assertTrue(Arrays.equals(new Object[0], a));
493	+	assertSame(Object[].class, a.getClass());
494	+	int size = 20;
495	+	Integer[] elements = new Integer[size];
496	+	for (int i = 0; i < size; i++)
497	+	elements[i] = i;
498	+	shuffle(elements);
499	+	Collection<Integer> full = populatedSet(elements);
500	+
501	+	assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray())));
502	+	assertTrue(full.containsAll(Arrays.asList(full.toArray())));
503	+	assertSame(Object[].class, full.toArray().getClass());
504	+	}
505	+
506	+	/**
507	+	* toArray(Integer array) returns an Integer array containing all
508	+	* elements from the set
509	+	*/
510	+	public void testToArray2() {
511	+	Collection empty = ConcurrentHashMap.newKeySet();
512	+	Integer[] a;
513	+	int size = 20;
514	+
515	+	a = new Integer[0];
516	+	assertSame(a, empty.toArray(a));
517	+
518	+	a = new Integer[size / 2];
519	+	Arrays.fill(a, 42);
520	+	assertSame(a, empty.toArray(a));
521	+	assertNull(a[0]);
522	+	for (int i = 1; i < a.length; i++)
523	+	assertEquals(42, (int) a[i]);
524	+
525	+	Integer[] elements = new Integer[size];
526	+	for (int i = 0; i < size; i++)
527	+	elements[i] = i;
528	+	shuffle(elements);
529	+	Collection<Integer> full = populatedSet(elements);
530	+
531	+	Arrays.fill(a, 42);
532	+	assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray(a))));
533	+	for (int i = 0; i < a.length; i++)
534	+	assertEquals(42, (int) a[i]);
535	+	assertSame(Integer[].class, full.toArray(a).getClass());
536	+
537	+	a = new Integer[size];
538	+	Arrays.fill(a, 42);
539	+	assertSame(a, full.toArray(a));
540	+	assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray(a))));
541	+	}
542	+
543	+	/**
544	+	* A deserialized serialized set is equal
545	+	*/
546	+	public void testSerialization() throws Exception {
547	+	int size = 20;
548	+	Set x = populatedSet(size);
549	+	Set y = serialClone(x);
550	+
551	+	assertNotSame(x, y);
552	+	assertEquals(x.size(), y.size());
553	+	assertEquals(x, y);
554	+	assertEquals(y, x);
555	+	}
556	+
557		static final int SIZE = 10000;
558		static ConcurrentHashMap<Long, Long> longMap;
559	<
559	>
560		static ConcurrentHashMap<Long, Long> longMap() {
561		if (longMap == null) {
562		longMap = new ConcurrentHashMap<Long, Long>(SIZE);
#	Line 147 | Line 566 | public class ConcurrentHashMap8Test exte
566		return longMap;
567		}
568
569	+	// explicit function class to avoid type inference problems
570	+	static class AddKeys implements BiFunction<Map.Entry<Long,Long>, Map.Entry<Long,Long>, Map.Entry<Long,Long>> {
571	+	public Map.Entry<Long,Long> apply(Map.Entry<Long,Long> x, Map.Entry<Long,Long> y) {
572	+	return new AbstractMap.SimpleEntry<Long,Long>
573	+	(Long.valueOf(x.getKey().longValue() + y.getKey().longValue()),
574	+	Long.valueOf(1L));
575	+	}
576	+	}
577	+
578		/**
579	<	* forEachKeySequentially, forEachValueSequentially,
152	<	* forEachEntrySequentially, forEachSequentially,
153	<	* forEachKeyInParallel, forEachValueInParallel,
154	<	* forEachEntryInParallel, forEachInParallel traverse all keys,
155	<	* values, entries, or mappings accordingly
579	>	* forEachKeySequentially traverses all keys
580		*/
581	<	public void testForEach() {
581	>	public void testForEachKeySequentially() {
582		LongAdder adder = new LongAdder();
583		ConcurrentHashMap<Long, Long> m = longMap();
584	<	m.forEachKeySequentially((Long x) -> adder.add(x.longValue()));
584	>	m.forEachKey(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
585		assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
586	<	adder.reset();
587	<	m.forEachValueSequentially((Long x) -> adder.add(x.longValue()));
586	>	}
587	>
588	>	/**
589	>	* forEachValueSequentially traverses all values
590	>	*/
591	>	public void testForEachValueSequentially() {
592	>	LongAdder adder = new LongAdder();
593	>	ConcurrentHashMap<Long, Long> m = longMap();
594	>	m.forEachValue(Long.MAX_VALUE, (Long x) -> adder.add(x.longValue()));
595		assertEquals(adder.sum(), SIZE * (SIZE - 1));
596	<	adder.reset();
597	<	m.forEachSequentially((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
596	>	}
597	>
598	>	/**
599	>	* forEachSequentially traverses all mappings
600	>	*/
601	>	public void testForEachSequentially() {
602	>	LongAdder adder = new LongAdder();
603	>	ConcurrentHashMap<Long, Long> m = longMap();
604	>	m.forEach(Long.MAX_VALUE, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
605		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
606	<	adder.reset();
607	<	m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
606	>	}
607	>
608	>	/**
609	>	* forEachEntrySequentially traverses all entries
610	>	*/
611	>	public void testForEachEntrySequentially() {
612	>	LongAdder adder = new LongAdder();
613	>	ConcurrentHashMap<Long, Long> m = longMap();
614	>	m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
615		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
616	<	adder.reset();
617	<	m.forEachKeyInParallel((Long x) -> adder.add(x.longValue()));
616	>	}
617	>
618	>	/**
619	>	* forEachKeyInParallel traverses all keys
620	>	*/
621	>	public void testForEachKeyInParallel() {
622	>	LongAdder adder = new LongAdder();
623	>	ConcurrentHashMap<Long, Long> m = longMap();
624	>	m.forEachKey(1L, (Long x) -> adder.add(x.longValue()));
625		assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
626	<	adder.reset();
627	<	m.forEachValueInParallel((Long x) -> adder.add(x.longValue()));
626	>	}
627	>
628	>	/**
629	>	* forEachValueInParallel traverses all values
630	>	*/
631	>	public void testForEachValueInParallel() {
632	>	LongAdder adder = new LongAdder();
633	>	ConcurrentHashMap<Long, Long> m = longMap();
634	>	m.forEachValue(1L, (Long x) -> adder.add(x.longValue()));
635		assertEquals(adder.sum(), SIZE * (SIZE - 1));
636	<	adder.reset();
637	<	m.forEachInParallel((Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
636	>	}
637	>
638	>	/**
639	>	* forEachInParallel traverses all mappings
640	>	*/
641	>	public void testForEachInParallel() {
642	>	LongAdder adder = new LongAdder();
643	>	ConcurrentHashMap<Long, Long> m = longMap();
644	>	m.forEach(1L, (Long x, Long y) -> adder.add(x.longValue() + y.longValue()));
645		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
646	<	adder.reset();
647	<	m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
646	>	}
647	>
648	>	/**
649	>	* forEachEntryInParallel traverses all entries
650	>	*/
651	>	public void testForEachEntryInParallel() {
652	>	LongAdder adder = new LongAdder();
653	>	ConcurrentHashMap<Long, Long> m = longMap();
654	>	m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue()));
655		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
656		}
657
658		/**
659	<	* Mapped forEachKeySequentially, forEachValueSequentially,
660	<	* forEachEntrySequentially, forEachSequentially,
188	<	* forEachKeyInParallel, forEachValueInParallel,
189	<	* forEachEntryInParallel, forEachInParallel traverse the given
190	<	* transformations of all keys, values, entries, or mappings
191	<	* accordingly
659	>	* Mapped forEachKeySequentially traverses the given
660	>	* transformations of all keys
661		*/
662	<	public void testMappedForEach() {
662	>	public void testMappedForEachKeySequentially() {
663		LongAdder adder = new LongAdder();
664		ConcurrentHashMap<Long, Long> m = longMap();
665	<	m.forEachKeySequentially((Long x) -> Long.valueOf(4 * x.longValue()),
665	>	m.forEachKey(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
666		(Long x) -> adder.add(x.longValue()));
667		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
668	<	adder.reset();
669	<	m.forEachValueSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
668	>	}
669	>
670	>	/**
671	>	* Mapped forEachValueSequentially traverses the given
672	>	* transformations of all values
673	>	*/
674	>	public void testMappedForEachValueSequentially() {
675	>	LongAdder adder = new LongAdder();
676	>	ConcurrentHashMap<Long, Long> m = longMap();
677	>	m.forEachValue(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
678		(Long x) -> adder.add(x.longValue()));
679		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
680	<	adder.reset();
681	<	m.forEachSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
680	>	}
681	>
682	>	/**
683	>	* Mapped forEachSequentially traverses the given
684	>	* transformations of all mappings
685	>	*/
686	>	public void testMappedForEachSequentially() {
687	>	LongAdder adder = new LongAdder();
688	>	ConcurrentHashMap<Long, Long> m = longMap();
689	>	m.forEach(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
690		(Long x) -> adder.add(x.longValue()));
691		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
692	<	adder.reset();
693	<	m.forEachEntrySequentially((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
692	>	}
693	>
694	>	/**
695	>	* Mapped forEachEntrySequentially traverses the given
696	>	* transformations of all entries
697	>	*/
698	>	public void testMappedForEachEntrySequentially() {
699	>	LongAdder adder = new LongAdder();
700	>	ConcurrentHashMap<Long, Long> m = longMap();
701	>	m.forEachEntry(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
702		(Long x) -> adder.add(x.longValue()));
703		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
704	<	adder.reset();
705	<	m.forEachKeyInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
704	>	}
705	>
706	>	/**
707	>	* Mapped forEachKeyInParallel traverses the given
708	>	* transformations of all keys
709	>	*/
710	>	public void testMappedForEachKeyInParallel() {
711	>	LongAdder adder = new LongAdder();
712	>	ConcurrentHashMap<Long, Long> m = longMap();
713	>	m.forEachKey(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
714		(Long x) -> adder.add(x.longValue()));
715		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
716	<	adder.reset();
717	<	m.forEachValueInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
716	>	}
717	>
718	>	/**
719	>	* Mapped forEachValueInParallel traverses the given
720	>	* transformations of all values
721	>	*/
722	>	public void testMappedForEachValueInParallel() {
723	>	LongAdder adder = new LongAdder();
724	>	ConcurrentHashMap<Long, Long> m = longMap();
725	>	m.forEachValue(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
726		(Long x) -> adder.add(x.longValue()));
727		assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
728	<	adder.reset();
729	<	m.forEachInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
728	>	}
729	>
730	>	/**
731	>	* Mapped forEachInParallel traverses the given
732	>	* transformations of all mappings
733	>	*/
734	>	public void testMappedForEachInParallel() {
735	>	LongAdder adder = new LongAdder();
736	>	ConcurrentHashMap<Long, Long> m = longMap();
737	>	m.forEach(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
738		(Long x) -> adder.add(x.longValue()));
739		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
740	<	adder.reset();
741	<	m.forEachEntryInParallel((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
740	>	}
741	>
742	>	/**
743	>	* Mapped forEachEntryInParallel traverses the given
744	>	* transformations of all entries
745	>	*/
746	>	public void testMappedForEachEntryInParallel() {
747	>	LongAdder adder = new LongAdder();
748	>	ConcurrentHashMap<Long, Long> m = longMap();
749	>	m.forEachEntry(1L, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
750		(Long x) -> adder.add(x.longValue()));
751		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
752		}
753
754		/**
755	<	* reduceKeysSequentially, reduceValuesSequentially,
231	<	* reduceSequentially, reduceEntriesSequentially,
232	<	* reduceKeysInParallel, reduceValuesInParallel, reduceInParallel,
233	<	* and reduceEntriesInParallel, accumulate across all keys,
234	<	* values, entries, or mappings accordingly
755	>	* reduceKeysSequentially accumulates across all keys,
756		*/
757	<	public void testReduce() {
757	>	public void testReduceKeysSequentially() {
758		ConcurrentHashMap<Long, Long> m = longMap();
759		Long r;
760	<	r = m.reduceKeysSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
760	>	r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
761		assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
762	<	r = m.reduceValuesSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
762	>	}
763	>
764	>	/**
765	>	* reduceValuesSequentially accumulates across all values
766	>	*/
767	>	public void testReduceValuesSequentially() {
768	>	ConcurrentHashMap<Long, Long> m = longMap();
769	>	Long r;
770	>	r = m.reduceKeys(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
771	>	assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
772	>	}
773	>
774	>	/**
775	>	* reduceEntriesSequentially accumulates across all entries
776	>	*/
777	>	public void testReduceEntriesSequentially() {
778	>	ConcurrentHashMap<Long, Long> m = longMap();
779	>	Map.Entry<Long,Long> r;
780	>	r = m.reduceEntries(Long.MAX_VALUE, new AddKeys());
781	>	assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
782	>	}
783	>
784	>	/**
785	>	* reduceKeysInParallel accumulates across all keys
786	>	*/
787	>	public void testReduceKeysInParallel() {
788	>	ConcurrentHashMap<Long, Long> m = longMap();
789	>	Long r;
790	>	r = m.reduceKeys(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
791	>	assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
792	>	}
793	>
794	>	/**
795	>	* reduceValuesInParallel accumulates across all values
796	>	*/
797	>	public void testReduceValuesInParallel() {
798	>	ConcurrentHashMap<Long, Long> m = longMap();
799	>	Long r;
800	>	r = m.reduceValues(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
801		assertEquals((long)r, (long)SIZE * (SIZE - 1));
802	<	r = m.reduceSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
802	>	}
803	>
804	>	/**
805	>	* reduceEntriesInParallel accumulate across all entries
806	>	*/
807	>	public void testReduceEntriesInParallel() {
808	>	ConcurrentHashMap<Long, Long> m = longMap();
809	>	Map.Entry<Long,Long> r;
810	>	r = m.reduceEntries(1L, new AddKeys());
811	>	assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
812	>	}
813	>
814	>	/**
815	>	* Mapped reduceKeysSequentially accumulates mapped keys
816	>	*/
817	>	public void testMapReduceKeysSequentially() {
818	>	ConcurrentHashMap<Long, Long> m = longMap();
819	>	Long r = m.reduceKeys(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
820	>	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
821	>	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
822	>	}
823	>
824	>	/**
825	>	* Mapped reduceValuesSequentially accumulates mapped values
826	>	*/
827	>	public void testMapReduceValuesSequentially() {
828	>	ConcurrentHashMap<Long, Long> m = longMap();
829	>	Long r = m.reduceValues(Long.MAX_VALUE, (Long x) -> Long.valueOf(4 * x.longValue()),
830	>	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
831	>	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
832	>	}
833	>
834	>	/**
835	>	* reduceSequentially accumulates across all transformed mappings
836	>	*/
837	>	public void testMappedReduceSequentially() {
838	>	ConcurrentHashMap<Long, Long> m = longMap();
839	>	Long r = m.reduce(Long.MAX_VALUE, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
840		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
841	<
246	<	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
247	<	r = m.reduceEntriesSequentially((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
248	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
841	>
842		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
843	+	}
844
845	<	r = m.reduceKeysInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
846	<	assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
847	<	r = m.reduceValuesInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
848	<	assertEquals((long)r, (long)SIZE * (SIZE - 1));
849	<	r = m.reduceInParallel((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
845	>	/**
846	>	* Mapped reduceKeysInParallel, accumulates mapped keys
847	>	*/
848	>	public void testMapReduceKeysInParallel() {
849	>	ConcurrentHashMap<Long, Long> m = longMap();
850	>	Long r = m.reduceKeys(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
851	>	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
852	>	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
853	>	}
854	>
855	>	/**
856	>	* Mapped reduceValuesInParallel accumulates mapped values
857	>	*/
858	>	public void testMapReduceValuesInParallel() {
859	>	ConcurrentHashMap<Long, Long> m = longMap();
860	>	Long r = m.reduceValues(1L, (Long x) -> Long.valueOf(4 * x.longValue()),
861	>	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
862	>	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
863	>	}
864	>
865	>	/**
866	>	* reduceInParallel accumulate across all transformed mappings
867	>	*/
868	>	public void testMappedReduceInParallel() {
869	>	ConcurrentHashMap<Long, Long> m = longMap();
870	>	Long r;
871	>	r = m.reduce(1L, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
872		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
873		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
258	–	r = m.reduceEntriesInParallel((Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
259	–	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
260	–	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
874		}
875
876	<	/*
877	<	* Mapped reduceKeysSequentially, reduceKeysToIntSequentially,
265	<	* reduceKeysToLongSequentially, reduceKeysToDoubleSequentially,
266	<	* reduceValuesSequentially, reduceValuesToLongSequentially,
267	<	* reduceValuesToDoubleSequentially, reduceKeysInParallel,
268	<	* reduceKeysToLongInParallel, reduceKeysToIntInParallel,
269	<	* reduceKeysToDoubleInParallel, reduceValuesInParallel,
270	<	* reduceValuesToLongInParallel, reduceValuesToIntInParallel,
271	<	* reduceValuesToDoubleInParallel accumulate mapped keys, values,
272	<	* entries, or mappings accordingly
876	>	/**
877	>	* reduceKeysToLongSequentially accumulates mapped keys
878		*/
879	<	public void testMapReduce() {
879	>	public void testReduceKeysToLongSequentially() {
880		ConcurrentHashMap<Long, Long> m = longMap();
881	<	Long r; long lr; int ir; double dr;
277	<	r = m.reduceKeysSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
278	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
279	<	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
280	<	lr = m.reduceKeysToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
881	>	long lr = m.reduceKeysToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
882		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
883	+	}
884	+
885	+	/**
886	+	* reduceKeysToIntSequentially accumulates mapped keys
887	+	*/
888	+	public void testReduceKeysToIntSequentially() {
889	+	ConcurrentHashMap<Long, Long> m = longMap();
890	+	int ir = m.reduceKeysToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
891	+	assertEquals(ir, SIZE * (SIZE - 1) / 2);
892	+	}
893
894	<	ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
895	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
896	<	dr = m.reduceKeysToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
894	>	/**
895	>	* reduceKeysToDoubleSequentially accumulates mapped keys
896	>	*/
897	>	public void testReduceKeysToDoubleSequentially() {
898	>	ConcurrentHashMap<Long, Long> m = longMap();
899	>	double dr = m.reduceKeysToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
900		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
901	+	}
902
903	<	r = m.reduceValuesSequentially((Long x) -> Long.valueOf(4 * x.longValue()),
904	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
905	<	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
906	<	lr = m.reduceValuesToLongSequentially((Long x) -> x.longValue(), 0L, Long::sum);
903	>	/**
904	>	* reduceValuesToLongSequentially accumulates mapped values
905	>	*/
906	>	public void testReduceValuesToLongSequentially() {
907	>	ConcurrentHashMap<Long, Long> m = longMap();
908	>	long lr = m.reduceValuesToLong(Long.MAX_VALUE, (Long x) -> x.longValue(), 0L, Long::sum);
909		assertEquals(lr, (long)SIZE * (SIZE - 1));
910	<	ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
294	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
910	>	}
911
912	<	dr = m.reduceValuesToDoubleSequentially((Long x) -> x.doubleValue(), 0.0, Double::sum);
912	>	/**
913	>	* reduceValuesToIntSequentially accumulates mapped values
914	>	*/
915	>	public void testReduceValuesToIntSequentially() {
916	>	ConcurrentHashMap<Long, Long> m = longMap();
917	>	int ir = m.reduceValuesToInt(Long.MAX_VALUE, (Long x) -> x.intValue(), 0, Integer::sum);
918	>	assertEquals(ir, SIZE * (SIZE - 1));
919	>	}
920	>
921	>	/**
922	>	* reduceValuesToDoubleSequentially accumulates mapped values
923	>	*/
924	>	public void testReduceValuesToDoubleSequentially() {
925	>	ConcurrentHashMap<Long, Long> m = longMap();
926	>	double dr = m.reduceValuesToDouble(Long.MAX_VALUE, (Long x) -> x.doubleValue(), 0.0, Double::sum);
927		assertEquals(dr, (double)SIZE * (SIZE - 1));
928	+	}
929
930	<	r = m.reduceKeysInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
931	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
932	<	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
933	<	lr = m.reduceKeysToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
930	>	/**
931	>	* reduceKeysToLongInParallel accumulates mapped keys
932	>	*/
933	>	public void testReduceKeysToLongInParallel() {
934	>	ConcurrentHashMap<Long, Long> m = longMap();
935	>	long lr = m.reduceKeysToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
936		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
937	<	ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
938	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
939	<	dr = m.reduceKeysToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
937	>	}
938	>
939	>	/**
940	>	* reduceKeysToIntInParallel accumulates mapped keys
941	>	*/
942	>	public void testReduceKeysToIntInParallel() {
943	>	ConcurrentHashMap<Long, Long> m = longMap();
944	>	int ir = m.reduceKeysToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
945	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
946	>	}
947	>
948	>	/**
949	>	* reduceKeysToDoubleInParallel accumulates mapped values
950	>	*/
951	>	public void testReduceKeysToDoubleInParallel() {
952	>	ConcurrentHashMap<Long, Long> m = longMap();
953	>	double dr = m.reduceKeysToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
954		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
955	+	}
956
957	<	r = m.reduceValuesInParallel((Long x) -> Long.valueOf(4 * x.longValue()),
958	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
959	<	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
960	<	lr = m.reduceValuesToLongInParallel((Long x) -> x.longValue(), 0L, Long::sum);
957	>	/**
958	>	* reduceValuesToLongInParallel accumulates mapped values
959	>	*/
960	>	public void testReduceValuesToLongInParallel() {
961	>	ConcurrentHashMap<Long, Long> m = longMap();
962	>	long lr = m.reduceValuesToLong(1L, (Long x) -> x.longValue(), 0L, Long::sum);
963		assertEquals(lr, (long)SIZE * (SIZE - 1));
964	<	ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
965	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
966	<	dr = m.reduceValuesToDoubleInParallel((Long x) -> x.doubleValue(), 0.0, Double::sum);
964	>	}
965	>
966	>	/**
967	>	* reduceValuesToIntInParallel accumulates mapped values
968	>	*/
969	>	public void testReduceValuesToIntInParallel() {
970	>	ConcurrentHashMap<Long, Long> m = longMap();
971	>	int ir = m.reduceValuesToInt(1L, (Long x) -> x.intValue(), 0, Integer::sum);
972	>	assertEquals(ir, SIZE * (SIZE - 1));
973	>	}
974	>
975	>	/**
976	>	* reduceValuesToDoubleInParallel accumulates mapped values
977	>	*/
978	>	public void testReduceValuesToDoubleInParallel() {
979	>	ConcurrentHashMap<Long, Long> m = longMap();
980	>	double dr = m.reduceValuesToDouble(1L, (Long x) -> x.doubleValue(), 0.0, Double::sum);
981		assertEquals(dr, (double)SIZE * (SIZE - 1));
982		}
983
984		/**
985	<	* searchKeysSequentially, searchValuesSequentially,
986	<	* searchSequentially, searchEntriesSequentially,
323	<	* searchKeysInParallel, searchValuesInParallel, searchInParallel,
324	<	* searchEntriesInParallel all return a non-null result of search
325	<	* function, or null if none, across keys, values, entries, or
326	<	* mappings accordingly
985	>	* searchKeysSequentially returns a non-null result of search
986	>	* function, or null if none
987		*/
988	<	public void testSearch() {
988	>	public void testSearchKeysSequentially() {
989		ConcurrentHashMap<Long, Long> m = longMap();
990		Long r;
991	<	r = m.searchKeysSequentially((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
332	<	assertEquals((long)r, (long)(SIZE/2));
333	<	r = m.searchValuesSequentially((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
334	<	assertEquals((long)r, (long)(SIZE/2));
335	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null);
991	>	r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
992		assertEquals((long)r, (long)(SIZE/2));
993	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null);
338	<	assertEquals((long)r, (long)(SIZE/2));
339	<
340	<	r = m.searchKeysSequentially((Long x) -> x.longValue() < 0L? x : null);
341	<	assertNull(r);
342	<	r = m.searchValuesSequentially((Long x) -> x.longValue() < 0L? x : null);
343	<	assertNull(r);
344	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() < 0L? x : null);
345	<	assertNull(r);
346	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L? e.getKey() : null);
993	>	r = m.searchKeys(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
994		assertNull(r);
995	+	}
996
997	<	r = m.searchKeysInParallel((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
998	<	assertEquals((long)r, (long)(SIZE/2));
999	<	r = m.searchValuesInParallel((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1000	<	assertEquals((long)r, (long)(SIZE/2));
1001	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null);
1002	<	assertEquals((long)r, (long)(SIZE/2));
1003	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null);
997	>	/**
998	>	* searchValuesSequentially returns a non-null result of search
999	>	* function, or null if none
1000	>	*/
1001	>	public void testSearchValuesSequentially() {
1002	>	ConcurrentHashMap<Long, Long> m = longMap();
1003	>	Long r;
1004	>	r = m.searchValues(Long.MAX_VALUE,
1005	>	(Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
1006		assertEquals((long)r, (long)(SIZE/2));
1007	<
1008	<	r = m.searchKeysInParallel((Long x) -> x.longValue() < 0L? x : null);
359	<	assertNull(r);
360	<	r = m.searchValuesInParallel((Long x) -> x.longValue() < 0L? x : null);
361	<	assertNull(r);
362	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() < 0L? x : null);
1007	>	r = m.searchValues(Long.MAX_VALUE,
1008	>	(Long x) -> (x.longValue() < 0L) ? x : null);
1009		assertNull(r);
1010	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L? e.getKey() : null);
1010	>	}
1011	>
1012	>	/**
1013	>	* searchSequentially returns a non-null result of search
1014	>	* function, or null if none
1015	>	*/
1016	>	public void testSearchSequentially() {
1017	>	ConcurrentHashMap<Long, Long> m = longMap();
1018	>	Long r;
1019	>	r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1020	>	assertEquals((long)r, (long)(SIZE/2));
1021	>	r = m.search(Long.MAX_VALUE, (Long x, Long y) -> x.longValue() < 0L ? x : null);
1022		assertNull(r);
1023		}
1024
1025		/**
1026	<	* Invoking task versions of bulk methods has same effect as
1027	<	* parallel methods
1026	>	* searchEntriesSequentially returns a non-null result of search
1027	>	* function, or null if none
1028		*/
1029	<	public void testForkJoinTasks() {
373	<	LongAdder adder = new LongAdder();
1029	>	public void testSearchEntriesSequentially() {
1030		ConcurrentHashMap<Long, Long> m = longMap();
1031	<	ConcurrentHashMap.ForkJoinTasks.forEachKey
1032	<	(m, (Long x) -> adder.add(x.longValue())).invoke();
1033	<	assertEquals(adder.sum(), SIZE * (SIZE - 1) / 2);
1034	<	adder.reset();
1035	<	ConcurrentHashMap.ForkJoinTasks.forEachValue
1036	<	(m, (Long x) -> adder.add(x.longValue())).invoke();
381	<	assertEquals(adder.sum(), SIZE * (SIZE - 1));
382	<	adder.reset();
383	<	ConcurrentHashMap.ForkJoinTasks.forEach
384	<	(m, (Long x, Long y) -> adder.add(x.longValue() + y.longValue())).invoke();
385	<	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
386	<	adder.reset();
387	<	ConcurrentHashMap.ForkJoinTasks.forEachEntry
388	<	(m,
389	<	(Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue())).invoke();
390	<	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
391	<	adder.reset();
392	<	ConcurrentHashMap.ForkJoinTasks.forEachKey
393	<	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
394	<	(Long x) -> adder.add(x.longValue())).invoke();
395	<	assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1) / 2);
396	<	adder.reset();
397	<	ConcurrentHashMap.ForkJoinTasks.forEachValue
398	<	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
399	<	(Long x) -> adder.add(x.longValue())).invoke();
400	<	assertEquals(adder.sum(), 4 * SIZE * (SIZE - 1));
401	<	adder.reset();
402	<	ConcurrentHashMap.ForkJoinTasks.forEach
403	<	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
404	<	(Long x) -> adder.add(x.longValue())).invoke();
405	<	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
406	<	adder.reset();
407	<	ConcurrentHashMap.ForkJoinTasks.forEachEntry
408	<	(m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
409	<	(Long x) -> adder.add(x.longValue())).invoke();
410	<	assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
411	<	adder.reset();
1031	>	Long r;
1032	>	r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1033	>	assertEquals((long)r, (long)(SIZE/2));
1034	>	r = m.searchEntries(Long.MAX_VALUE, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1035	>	assertNull(r);
1036	>	}
1037
1038	<	Long r; long lr; int ir; double dr;
1039	<	r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
1040	<	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1041	<	assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
1042	<	r = ConcurrentHashMap.ForkJoinTasks.reduceValues
1043	<	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
1044	<	assertEquals((long)r, (long)SIZE * (SIZE - 1));
1045	<	r = ConcurrentHashMap.ForkJoinTasks.reduce
421	<	(m, (Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
422	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
423	<	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
424	<	r = ConcurrentHashMap.ForkJoinTasks.reduceEntries
425	<	(m, (Map.Entry<Long,Long> e) -> Long.valueOf(e.getKey().longValue() + e.getValue().longValue()),
426	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
427	<	assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
428	<	r = ConcurrentHashMap.ForkJoinTasks.reduceKeys
429	<	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
430	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
431	<	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
432	<	lr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToLong
433	<	(m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
434	<	assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
435	<	ir = ConcurrentHashMap.ForkJoinTasks.reduceKeysToInt
436	<	(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
437	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
438	<	dr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToDouble
439	<	(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
440	<	assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
441	<	r = ConcurrentHashMap.ForkJoinTasks.reduceValues
442	<	(m, (Long x) -> Long.valueOf(4 * x.longValue()),
443	<	(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue())).invoke();
444	<	assertEquals((long)r, (long)4 * SIZE * (SIZE - 1));
445	<	lr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToLong
446	<	(m, (Long x) -> x.longValue(), 0L, Long::sum).invoke();
447	<	assertEquals(lr, (long)SIZE * (SIZE - 1));
448	<	ir = ConcurrentHashMap.ForkJoinTasks.reduceValuesToInt
449	<	(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
450	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
451	<	dr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToDouble
452	<	(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
453	<	assertEquals(dr, (double)SIZE * (SIZE - 1));
454	<	r = ConcurrentHashMap.ForkJoinTasks.searchKeys
455	<	(m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1038	>	/**
1039	>	* searchKeysInParallel returns a non-null result of search
1040	>	* function, or null if none
1041	>	*/
1042	>	public void testSearchKeysInParallel() {
1043	>	ConcurrentHashMap<Long, Long> m = longMap();
1044	>	Long r;
1045	>	r = m.searchKeys(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1046		assertEquals((long)r, (long)(SIZE/2));
1047	<	r = ConcurrentHashMap.ForkJoinTasks.searchValues
1048	<	(m, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1047	>	r = m.searchKeys(1L, (Long x) -> x.longValue() < 0L ? x : null);
1048	>	assertNull(r);
1049	>	}
1050	>
1051	>	/**
1052	>	* searchValuesInParallel returns a non-null result of search
1053	>	* function, or null if none
1054	>	*/
1055	>	public void testSearchValuesInParallel() {
1056	>	ConcurrentHashMap<Long, Long> m = longMap();
1057	>	Long r;
1058	>	r = m.searchValues(1L, (Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1059		assertEquals((long)r, (long)(SIZE/2));
1060	<	r = ConcurrentHashMap.ForkJoinTasks.search
1061	<	(m, (Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null).invoke();
1060	>	r = m.searchValues(1L, (Long x) -> x.longValue() < 0L ? x : null);
1061	>	assertNull(r);
1062	>	}
1063	>
1064	>	/**
1065	>	* searchInParallel returns a non-null result of search function,
1066	>	* or null if none
1067	>	*/
1068	>	public void testSearchInParallel() {
1069	>	ConcurrentHashMap<Long, Long> m = longMap();
1070	>	Long r;
1071	>	r = m.search(1L, (Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1072		assertEquals((long)r, (long)(SIZE/2));
1073	<	r = ConcurrentHashMap.ForkJoinTasks.searchEntries
1074	<	(m, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null).invoke();
1073	>	r = m.search(1L, (Long x, Long y) -> x.longValue() < 0L ? x : null);
1074	>	assertNull(r);
1075	>	}
1076	>
1077	>	/**
1078	>	* searchEntriesInParallel returns a non-null result of search
1079	>	* function, or null if none
1080	>	*/
1081	>	public void testSearchEntriesInParallel() {
1082	>	ConcurrentHashMap<Long, Long> m = longMap();
1083	>	Long r;
1084	>	r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1085		assertEquals((long)r, (long)(SIZE/2));
1086	<	}
1086	>	r = m.searchEntries(1L, (Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1087	>	assertNull(r);
1088	>	}
1089	>
1090		}

Diff Legend

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