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.25 by jsr166, Fri Feb 27 21:05:11 2015 UTC vs.
Revision 1.33 by jsr166, Sun Nov 6 22:42:10 2016 UTC

#	Line 11 | Line 11 | import static java.util.Spliterator.NONN
11		import java.util.AbstractMap;
12		import java.util.Arrays;
13		import java.util.Collection;
14	–	import java.util.Collections;
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.ExecutorService;
20	+	import java.util.concurrent.Executors;
21		import java.util.concurrent.ConcurrentHashMap;
22		import java.util.concurrent.atomic.LongAdder;
23		import java.util.function.BiFunction;
#	Line 26 | Line 27 | import junit.framework.TestSuite;
27
28		public class ConcurrentHashMap8Test extends JSR166TestCase {
29		public static void main(String[] args) {
30	<	junit.textui.TestRunner.run(suite());
30	>	main(suite(), args);
31		}
32		public static Test suite() {
33		return new TestSuite(ConcurrentHashMap8Test.class);
#	Line 62 | Line 63 | public class ConcurrentHashMap8Test exte
63		*/
64		public void testComputeIfAbsent() {
65		ConcurrentHashMap map = map5();
66	<	map.computeIfAbsent(six, (x) -> "Z");
66	>	map.computeIfAbsent(six, x -> "Z");
67		assertTrue(map.containsKey(six));
68		}
69
#	Line 71 | Line 72 | public class ConcurrentHashMap8Test exte
72		*/
73		public void testComputeIfAbsent2() {
74		ConcurrentHashMap map = map5();
75	<	assertEquals("A", map.computeIfAbsent(one, (x) -> "Z"));
75	>	assertEquals("A", map.computeIfAbsent(one, x -> "Z"));
76		}
77
78		/**
#	Line 79 | Line 80 | public class ConcurrentHashMap8Test exte
80		*/
81		public void testComputeIfAbsent3() {
82		ConcurrentHashMap map = map5();
83	<	map.computeIfAbsent(six, (x) -> null);
83	>	map.computeIfAbsent(six, x -> null);
84		assertFalse(map.containsKey(six));
85		}
86
#	Line 163 | Line 164 | public class ConcurrentHashMap8Test exte
164		Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
165		assertTrue(a.isEmpty());
166		for (int i = 0; i < n; i++)
167	<	a.add(i);
167	>	assertTrue(a.add(i));
168		assertEquals(n == 0, a.isEmpty());
169		assertEquals(n, a.size());
170		return a;
#	Line 173 | Line 174 | public class ConcurrentHashMap8Test exte
174		Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
175		assertTrue(a.isEmpty());
176		for (int i = 0; i < elements.length; i++)
177	<	a.add(elements[i]);
177	>	assertTrue(a.add(elements[i]));
178		assertFalse(a.isEmpty());
179		assertEquals(elements.length, a.size());
180		return a;
#	Line 299 | Line 300 | public class ConcurrentHashMap8Test exte
300		try {
301		map.keySet(null);
302		shouldThrow();
303	<	} catch (NullPointerException e) {}
303	>	} catch (NullPointerException success) {}
304		ConcurrentHashMap.KeySetView set = map.keySet(one);
305	<	set.add(one);
306	<	set.add(six);
307	<	set.add(seven);
305	>	assertFalse(set.add(one));
306	>	assertTrue(set.add(six));
307	>	assertTrue(set.add(seven));
308		assertTrue(set.getMappedValue() == one);
309		assertTrue(map.get(one) != one);
310		assertTrue(map.get(six) == one);
#	Line 406 | Line 407 | public class ConcurrentHashMap8Test exte
407		Integer[] elements = new Integer[size];
408		for (int i = 0; i < size; i++)
409		elements[i] = i;
410	<	Collections.shuffle(Arrays.asList(elements));
410	>	shuffle(elements);
411		Collection<Integer> full = populatedSet(elements);
412
413		Iterator it = full.iterator();
#	Line 496 | Line 497 | public class ConcurrentHashMap8Test exte
497		Integer[] elements = new Integer[size];
498		for (int i = 0; i < size; i++)
499		elements[i] = i;
500	<	Collections.shuffle(Arrays.asList(elements));
500	>	shuffle(elements);
501		Collection<Integer> full = populatedSet(elements);
502
503		assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray())));
#	Line 516 | Line 517 | public class ConcurrentHashMap8Test exte
517		a = new Integer[0];
518		assertSame(a, empty.toArray(a));
519
520	<	a = new Integer[size/2];
520	>	a = new Integer[size / 2];
521		Arrays.fill(a, 42);
522		assertSame(a, empty.toArray(a));
523		assertNull(a[0]);
#	Line 526 | Line 527 | public class ConcurrentHashMap8Test exte
527		Integer[] elements = new Integer[size];
528		for (int i = 0; i < size; i++)
529		elements[i] = i;
530	<	Collections.shuffle(Arrays.asList(elements));
530	>	shuffle(elements);
531		Collection<Integer> full = populatedSet(elements);
532
533		Arrays.fill(a, 42);
#	Line 1088 | Line 1089 | public class ConcurrentHashMap8Test exte
1089		assertNull(r);
1090		}
1091
1092	+	/**
1093	+	* Tests performance of computeIfAbsent when the element is present.
1094	+	* See JDK-8161372
1095	+	* ant -Djsr166.tckTestClass=ConcurrentHashMapTest -Djsr166.methodFilter=testcomputeIfAbsent_performance -Djsr166.expensiveTests=true tck
1096	+	*/
1097	+	public void testcomputeIfAbsent_performance() {
1098	+	final int mapSize = 20;
1099	+	final int iterations = expensiveTests ? (1 << 23) : mapSize * 2;
1100	+	final int threads = expensiveTests ? 10 : 2;
1101	+	final ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>();
1102	+	for (int i = 0; i < mapSize; i++)
1103	+	map.put(i, i);
1104	+	final ExecutorService pool = Executors.newFixedThreadPool(2);
1105	+	try (PoolCleaner cleaner = cleaner(pool)) {
1106	+	Runnable r = new CheckedRunnable() {
1107	+	public void realRun() {
1108	+	int result = 0;
1109	+	for (int i = 0; i < iterations; i++)
1110	+	result += map.computeIfAbsent(i % mapSize, k -> k + k);
1111	+	if (result == -42) throw new Error();
1112	+	}};
1113	+	for (int i = 0; i < threads; i++)
1114	+	pool.execute(r);
1115	+	}
1116	+	}
1117	+
1118		}

Diff Legend

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