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.21 by jsr166, Thu Jan 15 18:34:19 2015 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.function.*;
10	<	import java.util.concurrent.atomic.LongAdder;
7	>	import static java.util.Spliterator.CONCURRENT;
8	>	import static java.util.Spliterator.DISTINCT;
9	>	import static java.util.Spliterator.NONNULL;
10	>
11	>	import java.util.AbstractMap;
12	>	import java.util.Arrays;
13	>	import java.util.Collection;
14	>	import java.util.Collections;
15	>	import java.util.Iterator;
16	>	import java.util.Map;
17	>	import java.util.NoSuchElementException;
18	>	import java.util.Set;
19	>	import java.util.Spliterator;
20	>	import java.util.Vector;
21		import java.util.concurrent.ConcurrentHashMap;
22	<	import java.util.concurrent.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 209 | Line 223 | public class ConcurrentHashMap8Test exte
223		assertFalse(set2.contains(six));
224		}
225
212	–
226		/**
227		* keySet.addAll adds each element from the given collection
228		*/
#	Line 255 | Line 268 | public class ConcurrentHashMap8Test exte
268		assertTrue(full.contains(three));
269		}
270
271	+	/**
272	+	* keySet.add throws UnsupportedOperationException if no default
273	+	* mapped value
274	+	*/
275	+	public void testAdd4() {
276	+	Set full = map5().keySet();
277	+	try {
278	+	full.add(three);
279	+	shouldThrow();
280	+	} catch (UnsupportedOperationException e){}
281	+	}
282	+
283	+	/**
284	+	* keySet.add throws NullPointerException if the specified key is
285	+	* null
286	+	*/
287	+	public void testAdd5() {
288	+	Set full = populatedSet(3);
289	+	try {
290	+	full.add(null);
291	+	shouldThrow();
292	+	} catch (NullPointerException e){}
293	+	}
294	+
295	+	/**
296	+	* KeySetView.getMappedValue returns the map's mapped value
297	+	*/
298	+	public void testGetMappedValue() {
299	+	ConcurrentHashMap map = map5();
300	+	assertNull(map.keySet().getMappedValue());
301	+	try {
302	+	map.keySet(null);
303	+	shouldThrow();
304	+	} catch (NullPointerException e) {}
305	+	ConcurrentHashMap.KeySetView set = map.keySet(one);
306	+	set.add(one);
307	+	set.add(six);
308	+	set.add(seven);
309	+	assertTrue(set.getMappedValue() == one);
310	+	assertTrue(map.get(one) != one);
311	+	assertTrue(map.get(six) == one);
312	+	assertTrue(map.get(seven) == one);
313	+	}
314	+
315	+	void checkSpliteratorCharacteristics(Spliterator<?> sp,
316	+	int requiredCharacteristics) {
317	+	assertEquals(requiredCharacteristics,
318	+	requiredCharacteristics & sp.characteristics());
319	+	}
320
321	<	/**
322	<	* keySet.add throws UnsupportedOperationException if no default
323	<	* mapped value
324	<	*/
325	<	public void testAdd4() {
326	<	Set full = map5().keySet();
327	<	try {
328	<	full.add(three);
329	<	shouldThrow();
330	<	} catch (UnsupportedOperationException e){}
331	<	}
332	<
333	<	/**
334	<	* keySet.add throws NullPointerException if the specified key is
335	<	* null
336	<	*/
337	<	public void testAdd5() {
276	<	Set full = populatedSet(3);
277	<	try {
278	<	full.add(null);
279	<	shouldThrow();
280	<	} catch (NullPointerException e){}
281	<	}
282	<
283	<	/**
284	<	* KeySetView.getMappedValue returns the map's mapped value
285	<	*/
286	<	public void testGetMappedValue() {
287	<	ConcurrentHashMap map = map5();
288	<	assertNull(map.keySet().getMappedValue());
289	<	try {
290	<	map.keySet(null);
291	<	shouldThrow();
292	<	} catch (NullPointerException e) {}
293	<	KeySetView set = map.keySet(one);
294	<	set.add(one);
295	<	set.add(six);
296	<	set.add(seven);
297	<	assertTrue(set.getMappedValue() == one);
298	<	assertTrue(map.get(one) != one);
299	<	assertTrue(map.get(six) == one);
300	<	assertTrue(map.get(seven) == one);
301	<	}
302	<
303	<	/**
304	<	* KeySetView.spliterator returns spliterator over the elements in this set
305	<	*/
306	<	public void testKeySetSpliterator() {
307	<	LongAdder adder = new LongAdder();
308	<	ConcurrentHashMap map = map5();
309	<	Set set = map.keySet();
310	<	Spliterator<Integer> sp = set.spliterator();
311	<	assertEquals(sp.estimateSize(), map.size());
312	<	Spliterator<Integer> sp2 = sp.trySplit();
313	<	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	<
321	>	/**
322	>	* KeySetView.spliterator returns spliterator over the elements in this set
323	>	*/
324	>	public void testKeySetSpliterator() {
325	>	LongAdder adder = new LongAdder();
326	>	ConcurrentHashMap map = map5();
327	>	Set set = map.keySet();
328	>	Spliterator<Integer> sp = set.spliterator();
329	>	checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
330	>	assertEquals(sp.estimateSize(), map.size());
331	>	Spliterator<Integer> sp2 = sp.trySplit();
332	>	sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
333	>	long v = adder.sumThenReset();
334	>	sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
335	>	long v2 = adder.sum();
336	>	assertEquals(v + v2, 15);
337	>	}
338
339		/**
340		* keyset.clear removes all elements from the set
#	Line 533 | Line 551 | public class ConcurrentHashMap8Test exte
551
552		assertNotSame(x, y);
553		assertEquals(x.size(), y.size());
536	–	assertEquals(x.toString(), y.toString());
537	–	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
554		assertEquals(x, y);
555		assertEquals(y, x);
556		}
#	Line 986 | Line 1002 | public class ConcurrentHashMap8Test exte
1002		public void testSearchValuesSequentially() {
1003		ConcurrentHashMap<Long, Long> m = longMap();
1004		Long r;
1005	<	r = m.searchValues(Long.MAX_VALUE, (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.searchValues(Long.MAX_VALUE, (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

Diff Legend

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