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.12 by dl, Sun Jul 21 22:24:18 2013 UTC vs.
Revision 1.20 by jsr166, Wed Dec 31 21:39:07 2014 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.function.*;
10	<	import java.util.concurrent.atomic.LongAdder;
7	>	import static java.util.Spliterator.CONCURRENT;
8	>	import static java.util.Spliterator.DISTINCT;
9	>	import static java.util.Spliterator.NONNULL;
10	>
11	>	import java.util.AbstractMap;
12	>	import java.util.Arrays;
13	>	import java.util.Collection;
14	>	import java.util.Collections;
15	>	import java.util.Iterator;
16	>	import java.util.Map;
17	>	import java.util.NoSuchElementException;
18	>	import java.util.Set;
19	>	import java.util.Spliterator;
20	>	import java.util.Vector;
21		import java.util.concurrent.ConcurrentHashMap;
22	<	import java.util.concurrent.ConcurrentHashMap.KeySetView;
22	>	import java.util.concurrent.atomic.LongAdder;
23	>	import java.util.function.BiFunction;
24	>
25	>	import junit.framework.Test;
26	>	import junit.framework.TestSuite;
27
28		public class ConcurrentHashMap8Test extends JSR166TestCase {
29		public static void main(String[] args) {
#	Line 54 | Line 68 | public class ConcurrentHashMap8Test exte
68		}
69
70		/**
71	<	* computeIfAbsent does not replace  if the key is already present
71	>	* computeIfAbsent does not replace if the key is already present
72		*/
73		public void testComputeIfAbsent2() {
74		ConcurrentHashMap map = map5();
#	Line 71 | Line 85 | public class ConcurrentHashMap8Test exte
85		}
86
87		/**
88	<	* computeIfPresent does not replace  if the key is already present
88	>	* computeIfPresent does not replace if the key is already present
89		*/
90		public void testComputeIfPresent() {
91		ConcurrentHashMap map = map5();
#	Line 88 | Line 102 | public class ConcurrentHashMap8Test exte
102		}
103
104		/**
105	<	* compute does not replace  if the function returns null
105	>	* compute does not replace if the function returns null
106		*/
107		public void testCompute() {
108		ConcurrentHashMap map = map5();
#	Line 166 | Line 180 | public class ConcurrentHashMap8Test exte
180		return a;
181		}
182
183	<	/*
183	>	/**
184		* replaceAll replaces all matching values.
185		*/
186		public void testReplaceAll() {
187		ConcurrentHashMap<Integer, String> map = map5();
188	<	map.replaceAll((x, y) -> {return x > 3 ? "Z" : y;});
188	>	map.replaceAll((x, y) -> { return x > 3 ? "Z" : y; });
189		assertEquals("A", map.get(one));
190		assertEquals("B", map.get(two));
191		assertEquals("C", map.get(three));
#	Line 196 | Line 210 | public class ConcurrentHashMap8Test exte
210		Set set1 = map.keySet();
211		Set set2 = map.keySet(true);
212		set2.add(six);
213	<	assertTrue(((KeySetView)set2).getMap() == map);
214	<	assertTrue(((KeySetView)set1).getMap() == map);
213	>	assertTrue(((ConcurrentHashMap.KeySetView)set2).getMap() == map);
214	>	assertTrue(((ConcurrentHashMap.KeySetView)set1).getMap() == map);
215		assertEquals(set2.size(), map.size());
216		assertEquals(set1.size(), map.size());
217		assertTrue((Boolean)map.get(six));
#	Line 255 | Line 269 | public class ConcurrentHashMap8Test exte
269		assertTrue(full.contains(three));
270		}
271
272	+	/**
273	+	* keySet.add throws UnsupportedOperationException if no default
274	+	* mapped value
275	+	*/
276	+	public void testAdd4() {
277	+	Set full = map5().keySet();
278	+	try {
279	+	full.add(three);
280	+	shouldThrow();
281	+	} catch (UnsupportedOperationException e){}
282	+	}
283
284	<	/**
285	<	* keySet.add throws UnsupportedOperationException if no default
286	<	* mapped value
287	<	*/
288	<	public void testAdd4() {
289	<	Set full = map5().keySet();
290	<	try {
291	<	full.add(three);
292	<	shouldThrow();
293	<	} catch (UnsupportedOperationException e){}
294	<	}
295	<
296	<	/**
297	<	* keySet.add throws NullPointerException if the specified key is
298	<	* null
299	<	*/
300	<	public void testAdd5() {
301	<	Set full = populatedSet(3);
302	<	try {
303	<	full.add(null);
304	<	shouldThrow();
305	<	} catch (NullPointerException e){}
306	<	}
307	<
308	<	/**
309	<	* KeySetView.getMappedValue returns the map's mapped value
310	<	*/
311	<	public void testGetMappedValue() {
312	<	ConcurrentHashMap map = map5();
313	<	assertNull(map.keySet().getMappedValue());
314	<	try {
315	<	map.keySet(null);
316	<	shouldThrow();
317	<	} catch (NullPointerException e) {}
318	<	KeySetView set = map.keySet(one);
319	<	set.add(one);
320	<	set.add(six);
321	<	set.add(seven);
322	<	assertTrue(set.getMappedValue() == one);
323	<	assertTrue(map.get(one) != one);
324	<	assertTrue(map.get(six) == one);
325	<	assertTrue(map.get(seven) == one);
326	<	}
327	<
328	<	/**
329	<	* KeySetView.spliterator returns spliterator over the elements in this set
330	<	*/
331	<	public void testKeySetSpliterator() {
332	<	LongAdder adder = new LongAdder();
333	<	ConcurrentHashMap map = map5();
334	<	Set set = map.keySet();
335	<	Spliterator<Integer> sp = set.spliterator();
336	<	assertEquals(sp.estimateSize(), map.size());
337	<	Spliterator<Integer> sp2 = sp.trySplit();
338	<	sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
314	<	long v = adder.sumThenReset();
315	<	sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
316	<	long v2 = adder.sum();
317	<	assertEquals(v + v2, 15);
318	<	}
319	<
284	>	/**
285	>	* keySet.add throws NullPointerException if the specified key is
286	>	* null
287	>	*/
288	>	public void testAdd5() {
289	>	Set full = populatedSet(3);
290	>	try {
291	>	full.add(null);
292	>	shouldThrow();
293	>	} catch (NullPointerException e){}
294	>	}
295	>
296	>	/**
297	>	* KeySetView.getMappedValue returns the map's mapped value
298	>	*/
299	>	public void testGetMappedValue() {
300	>	ConcurrentHashMap map = map5();
301	>	assertNull(map.keySet().getMappedValue());
302	>	try {
303	>	map.keySet(null);
304	>	shouldThrow();
305	>	} catch (NullPointerException e) {}
306	>	ConcurrentHashMap.KeySetView set = map.keySet(one);
307	>	set.add(one);
308	>	set.add(six);
309	>	set.add(seven);
310	>	assertTrue(set.getMappedValue() == one);
311	>	assertTrue(map.get(one) != one);
312	>	assertTrue(map.get(six) == one);
313	>	assertTrue(map.get(seven) == one);
314	>	}
315	>
316	>	void checkSpliteratorCharacteristics(Spliterator<?> sp,
317	>	int requiredCharacteristics) {
318	>	assertEquals(requiredCharacteristics,
319	>	requiredCharacteristics & sp.characteristics());
320	>	}
321	>
322	>	/**
323	>	* KeySetView.spliterator returns spliterator over the elements in this set
324	>	*/
325	>	public void testKeySetSpliterator() {
326	>	LongAdder adder = new LongAdder();
327	>	ConcurrentHashMap map = map5();
328	>	Set set = map.keySet();
329	>	Spliterator<Integer> sp = set.spliterator();
330	>	checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
331	>	assertEquals(sp.estimateSize(), map.size());
332	>	Spliterator<Integer> sp2 = sp.trySplit();
333	>	sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
334	>	long v = adder.sumThenReset();
335	>	sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
336	>	long v2 = adder.sum();
337	>	assertEquals(v + v2, 15);
338	>	}
339
340		/**
341		* keyset.clear removes all elements from the set
#	Line 533 | Line 552 | public class ConcurrentHashMap8Test exte
552
553		assertNotSame(x, y);
554		assertEquals(x.size(), y.size());
536	–	assertEquals(x.toString(), y.toString());
537	–	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
555		assertEquals(x, y);
556		assertEquals(y, x);
557		}
#	Line 986 | Line 1003 | public class ConcurrentHashMap8Test exte
1003		public void testSearchValuesSequentially() {
1004		ConcurrentHashMap<Long, Long> m = longMap();
1005		Long r;
1006	<	r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1006	>	r = m.searchValues(Long.MAX_VALUE,
1007	>	(Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
1008		assertEquals((long)r, (long)(SIZE/2));
1009	<	r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
1009	>	r = m.searchValues(Long.MAX_VALUE,
1010	>	(Long x) -> (x.longValue() < 0L) ? x : null);
1011		assertNull(r);
1012		}
1013

Diff Legend

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