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.3 by dl, Fri Mar 22 14:11:32 2013 UTC vs.
Revision 1.7 by jsr166, Thu Apr 11 19:54:13 2013 UTC

#	Line 34 | Line 34 | public class ConcurrentHashMap8Test exte
34		return map;
35		}
36
37	+	// classes for testing Comparable fallbacks
38	+	static class BI implements Comparable<BI> {
39	+	private final int value;
40	+	BI(int value) { this.value = value; }
41	+	public int compareTo(BI other) {
42	+	return Integer.compare(value, other.value);
43	+	}
44	+	public boolean equals(Object x) {
45	+	return (x instanceof BI) && ((BI)x).value == value;
46	+	}
47	+	public int hashCode() { return 42; }
48	+	}
49	+	static class CI extends BI { CI(int value) { super(value); } }
50	+	static class DI extends BI { DI(int value) { super(value); } }
51	+
52	+	static class BS implements Comparable<BS> {
53	+	private final String value;
54	+	BS(String value) { this.value = value; }
55	+	public int compareTo(BS other) {
56	+	return value.compareTo(other.value);
57	+	}
58	+	public boolean equals(Object x) {
59	+	return (x instanceof BS) && value.equals(((BS)x).value);
60	+	}
61	+	public int hashCode() { return 42; }
62	+	}
63	+
64	+	static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
65	+	implements Comparable<LexicographicList<E>> {
66	+	LexicographicList(Collection<E> c) { super(c); }
67	+	LexicographicList(E e) { super(Collections.singleton(e)); }
68	+	public int compareTo(LexicographicList<E> other) {
69	+	int common = Math.min(size(), other.size());
70	+	int r = 0;
71	+	for (int i = 0; i < common; i++) {
72	+	if ((r = get(i).compareTo(other.get(i))) != 0)
73	+	break;
74	+	}
75	+	if (r == 0)
76	+	r = Integer.compare(size(), other.size());
77	+	return r;
78	+	}
79	+	private static final long serialVersionUID = 0;
80	+	}
81	+
82	+	/**
83	+	* Inserted elements that are subclasses of the same Comparable
84	+	* class are found.
85	+	*/
86	+	public void testComparableFamily() {
87	+	ConcurrentHashMap<BI, Boolean> m = new ConcurrentHashMap<>();
88	+	for (int i = 0; i < 1000; i++) {
89	+	assertTrue(m.put(new CI(i), true) == null);
90	+	}
91	+	for (int i = 0; i < 1000; i++) {
92	+	assertTrue(m.containsKey(new CI(i)));
93	+	assertTrue(m.containsKey(new DI(i)));
94	+	}
95	+	}
96	+
97	+	/**
98	+	* Elements of classes with erased generic type parameters based
99	+	* on Comparable can be inserted and found.
100	+	*/
101	+	public void testGenericComparable() {
102	+	ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
103	+	for (int i = 0; i < 1000; i++) {
104	+	BI bi = new BI(i);
105	+	BS bs = new BS(String.valueOf(i));
106	+	LexicographicList<BI> bis = new LexicographicList<BI>(bi);
107	+	LexicographicList<BS> bss = new LexicographicList<BS>(bs);
108	+	assertTrue(m.putIfAbsent(bis, true) == null);
109	+	assertTrue(m.containsKey(bis));
110	+	if (m.putIfAbsent(bss, true) == null)
111	+	assertTrue(m.containsKey(bss));
112	+	assertTrue(m.containsKey(bis));
113	+	}
114	+	for (int i = 0; i < 1000; i++) {
115	+	assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
116	+	}
117	+	}
118	+
119	+	/**
120	+	* Elements of non-comparable classes equal to those of classes
121	+	* with erased generic type parameters based on Comparable can be
122	+	* inserted and found.
123	+	*/
124	+	public void testGenericComparable2() {
125	+	ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
126	+	for (int i = 0; i < 1000; i++) {
127	+	m.put(new ArrayList(Collections.singleton(new BI(i))), true);
128	+	}
129	+
130	+	for (int i = 0; i < 1000; i++) {
131	+	LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
132	+	assertTrue(m.containsKey(bis));
133	+	}
134	+	}
135	+
136		/**
137		* getOrDefault returns value if present, else default
138		*/
#	Line 68 | Line 167 | public class ConcurrentHashMap8Test exte
167		map.computeIfAbsent(six, (x) -> null);
168		assertFalse(map.containsKey(six));
169		}
170	<
170	>
171		/**
172		* computeIfPresent does not replace  if the key is already present
173		*/
#	Line 380 | Line 479 | public class ConcurrentHashMap8Test exte
479		elements[i] = i;
480		Collections.shuffle(Arrays.asList(elements));
481		Collection<Integer> full = populatedSet(elements);
482	<
482	>
483		assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray())));
484		assertTrue(full.containsAll(Arrays.asList(full.toArray())));
485		assertSame(Object[].class, full.toArray().getClass());
#	Line 442 | Line 541 | public class ConcurrentHashMap8Test exte
541
542		static final int SIZE = 10000;
543		static ConcurrentHashMap<Long, Long> longMap;
544	<
544	>
545		static ConcurrentHashMap<Long, Long> longMap() {
546		if (longMap == null) {
547		longMap = new ConcurrentHashMap<Long, Long>(SIZE);
#	Line 456 | Line 555 | public class ConcurrentHashMap8Test exte
555		static class AddKeys implements BiFunction<Map.Entry<Long,Long>, Map.Entry<Long,Long>, Map.Entry<Long,Long>> {
556		public Map.Entry<Long,Long> apply(Map.Entry<Long,Long> x, Map.Entry<Long,Long> y) {
557		return new AbstractMap.SimpleEntry<Long,Long>
558	<	(Long.valueOf(x.getKey().longValue() + y.getKey().longValue()),
558	>	(Long.valueOf(x.getKey().longValue() + y.getKey().longValue()),
559		Long.valueOf(1L));
560		}
561		}
#	Line 699 | Line 798 | public class ConcurrentHashMap8Test exte
798		assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
799		}
800
801	<	/*
801	>	/**
802		* Mapped reduceKeysSequentially accumulates mapped keys
803		*/
804		public void testMapReduceKeysSequentially() {
#	Line 709 | Line 808 | public class ConcurrentHashMap8Test exte
808		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
809		}
810
811	<	/*
811	>	/**
812		* Mapped reduceValuesSequentially accumulates mapped values
813		*/
814		public void testMapReduceValuesSequentially() {
#	Line 726 | Line 825 | public class ConcurrentHashMap8Test exte
825		ConcurrentHashMap<Long, Long> m = longMap();
826		Long r = m.reduceSequentially((Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()),
827		(Long x, Long y) -> Long.valueOf(x.longValue() + y.longValue()));
828	<
828	>
829		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
830		}
831
832	<	/*
832	>	/**
833		* Mapped reduceKeysInParallel, accumulates mapped keys
834		*/
835		public void testMapReduceKeysInParallel() {
#	Line 740 | Line 839 | public class ConcurrentHashMap8Test exte
839		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
840		}
841
842	<	/*
842	>	/**
843		* Mapped reduceValuesInParallel accumulates mapped values
844		*/
845		public void testMapReduceValuesInParallel() {
#	Line 762 | Line 861 | public class ConcurrentHashMap8Test exte
861		}
862
863
864	<	/*
864	>	/**
865		* reduceKeysToLongSequentially accumulates mapped keys
866		*/
867		public void testReduceKeysToLongSequentially() {
#	Line 771 | Line 870 | public class ConcurrentHashMap8Test exte
870		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
871		}
872
873	<	/*
873	>	/**
874		* reduceKeysToIntSequentially accumulates mapped keys
875		*/
876		public void testReduceKeysToIntSequentially() {
877		ConcurrentHashMap<Long, Long> m = longMap();
878		int ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
879	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
879	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
880		}
881
882	<	/*
882	>	/**
883		* reduceKeysToDoubleSequentially accumulates mapped keys
884		*/
885		public void testReduceKeysToDoubleSequentially() {
#	Line 789 | Line 888 | public class ConcurrentHashMap8Test exte
888		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
889		}
890
891	<	/*
891	>	/**
892		* reduceValuesToLongSequentially accumulates mapped values
893		*/
894		public void testReduceValuesToLongSequentially() {
#	Line 798 | Line 897 | public class ConcurrentHashMap8Test exte
897		assertEquals(lr, (long)SIZE * (SIZE - 1));
898		}
899
900	<	/*
900	>	/**
901		* reduceValuesToIntSequentially accumulates mapped values
902		*/
903		public void testReduceValuesToIntSequentially() {
904		ConcurrentHashMap<Long, Long> m = longMap();
905		int ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
906	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
906	>	assertEquals(ir, SIZE * (SIZE - 1));
907		}
908
909	<	/*
909	>	/**
910		* reduceValuesToDoubleSequentially accumulates mapped values
911		*/
912		public void testReduceValuesToDoubleSequentially() {
#	Line 816 | Line 915 | public class ConcurrentHashMap8Test exte
915		assertEquals(dr, (double)SIZE * (SIZE - 1));
916		}
917
918	<	/*
918	>	/**
919		* reduceKeysToLongInParallel accumulates mapped keys
920		*/
921		public void testReduceKeysToLongInParallel() {
#	Line 825 | Line 924 | public class ConcurrentHashMap8Test exte
924		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
925		}
926
927	<	/*
927	>	/**
928		* reduceKeysToIntInParallel accumulates mapped keys
929		*/
930		public void testReduceKeysToIntInParallel() {
931		ConcurrentHashMap<Long, Long> m = longMap();
932		int ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
933	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
933	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
934		}
935
936	<	/*
936	>	/**
937		* reduceKeysToDoubleInParallel accumulates mapped values
938		*/
939		public void testReduceKeysToDoubleInParallel() {
#	Line 843 | Line 942 | public class ConcurrentHashMap8Test exte
942		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
943		}
944
945	<	/*
945	>	/**
946		* reduceValuesToLongInParallel accumulates mapped values
947		*/
948		public void testReduceValuesToLongInParallel() {
#	Line 852 | Line 951 | public class ConcurrentHashMap8Test exte
951		assertEquals(lr, (long)SIZE * (SIZE - 1));
952		}
953
954	<	/*
954	>	/**
955		* reduceValuesToIntInParallel accumulates mapped values
956		*/
957		public void testReduceValuesToIntInParallel() {
958		ConcurrentHashMap<Long, Long> m = longMap();
959		int ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
960	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
960	>	assertEquals(ir, SIZE * (SIZE - 1));
961		}
962
963	<	/*
963	>	/**
964		* reduceValuesToDoubleInParallel accumulates mapped values
965		*/
966		public void testReduceValuesToDoubleInParallel() {
#	Line 877 | Line 976 | public class ConcurrentHashMap8Test exte
976		public void testSearchKeysSequentially() {
977		ConcurrentHashMap<Long, Long> m = longMap();
978		Long r;
979	<	r = m.searchKeysSequentially((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
979	>	r = m.searchKeysSequentially((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
980		assertEquals((long)r, (long)(SIZE/2));
981	<	r = m.searchKeysSequentially((Long x) -> x.longValue() < 0L? x : null);
981	>	r = m.searchKeysSequentially((Long x) -> x.longValue() < 0L ? x : null);
982		assertNull(r);
983		}
984
#	Line 892 | Line 991 | public class ConcurrentHashMap8Test exte
991		Long r;
992		r = m.searchValuesSequentially((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
993		assertEquals((long)r, (long)(SIZE/2));
994	<	r = m.searchValuesSequentially((Long x) -> x.longValue() < 0L? x : null);
994	>	r = m.searchValuesSequentially((Long x) -> x.longValue() < 0L ? x : null);
995		assertNull(r);
996		}
997
#	Line 903 | Line 1002 | public class ConcurrentHashMap8Test exte
1002		public void testSearchSequentially() {
1003		ConcurrentHashMap<Long, Long> m = longMap();
1004		Long r;
1005	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null);
1005	>	r = m.searchSequentially((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1006		assertEquals((long)r, (long)(SIZE/2));
1007	<	r = m.searchSequentially((Long x, Long y) -> x.longValue() < 0L? x : null);
1007	>	r = m.searchSequentially((Long x, Long y) -> x.longValue() < 0L ? x : null);
1008		assertNull(r);
1009		}
1010
#	Line 916 | Line 1015 | public class ConcurrentHashMap8Test exte
1015		public void testSearchEntriesSequentially() {
1016		ConcurrentHashMap<Long, Long> m = longMap();
1017		Long r;
1018	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null);
1018	>	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1019		assertEquals((long)r, (long)(SIZE/2));
1020	<	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L? e.getKey() : null);
1020	>	r = m.searchEntriesSequentially((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1021		assertNull(r);
1022		}
1023
#	Line 929 | Line 1028 | public class ConcurrentHashMap8Test exte
1028		public void testSearchKeysInParallel() {
1029		ConcurrentHashMap<Long, Long> m = longMap();
1030		Long r;
1031	<	r = m.searchKeysInParallel((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1031	>	r = m.searchKeysInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1032		assertEquals((long)r, (long)(SIZE/2));
1033	<	r = m.searchKeysInParallel((Long x) -> x.longValue() < 0L? x : null);
1033	>	r = m.searchKeysInParallel((Long x) -> x.longValue() < 0L ? x : null);
1034		assertNull(r);
1035		}
1036
#	Line 942 | Line 1041 | public class ConcurrentHashMap8Test exte
1041		public void testSearchValuesInParallel() {
1042		ConcurrentHashMap<Long, Long> m = longMap();
1043		Long r;
1044	<	r = m.searchValuesInParallel((Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1044	>	r = m.searchValuesInParallel((Long x) -> x.longValue() == (long)(SIZE/2) ? x : null);
1045		assertEquals((long)r, (long)(SIZE/2));
1046	<	r = m.searchValuesInParallel((Long x) -> x.longValue() < 0L? x : null);
1046	>	r = m.searchValuesInParallel((Long x) -> x.longValue() < 0L ? x : null);
1047		assertNull(r);
1048		}
1049
#	Line 955 | Line 1054 | public class ConcurrentHashMap8Test exte
1054		public void testSearchInParallel() {
1055		ConcurrentHashMap<Long, Long> m = longMap();
1056		Long r;
1057	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() == (long)(SIZE/2)? x : null);
1057	>	r = m.searchInParallel((Long x, Long y) -> x.longValue() == (long)(SIZE/2) ? x : null);
1058		assertEquals((long)r, (long)(SIZE/2));
1059	<	r = m.searchInParallel((Long x, Long y) -> x.longValue() < 0L? x : null);
1059	>	r = m.searchInParallel((Long x, Long y) -> x.longValue() < 0L ? x : null);
1060		assertNull(r);
1061		}
1062
#	Line 968 | Line 1067 | public class ConcurrentHashMap8Test exte
1067		public void testSearchEntriesInParallel() {
1068		ConcurrentHashMap<Long, Long> m = longMap();
1069		Long r;
1070	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null);
1070	>	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2) ? e.getKey() : null);
1071		assertEquals((long)r, (long)(SIZE/2));
1072	<	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L? e.getKey() : null);
1072	>	r = m.searchEntriesInParallel((Map.Entry<Long,Long> e) -> e.getKey().longValue() < 0L ? e.getKey() : null);
1073		assertNull(r);
1074		}
1075
#	Line 994 | Line 1093 | public class ConcurrentHashMap8Test exte
1093		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1094		adder.reset();
1095		ConcurrentHashMap.ForkJoinTasks.forEachEntry
1096	<	(m,
1096	>	(m,
1097		(Map.Entry<Long,Long> e) -> adder.add(e.getKey().longValue() + e.getValue().longValue())).invoke();
1098		assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
1099		adder.reset();
#	Line 1043 | Line 1142 | public class ConcurrentHashMap8Test exte
1142		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
1143		ir = ConcurrentHashMap.ForkJoinTasks.reduceKeysToInt
1144		(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1145	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
1145	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
1146		dr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToDouble
1147		(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1148		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
#	Line 1056 | Line 1155 | public class ConcurrentHashMap8Test exte
1155		assertEquals(lr, (long)SIZE * (SIZE - 1));
1156		ir = ConcurrentHashMap.ForkJoinTasks.reduceValuesToInt
1157		(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1158	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
1158	>	assertEquals(ir, SIZE * (SIZE - 1));
1159		dr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToDouble
1160		(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1161		assertEquals(dr, (double)SIZE * (SIZE - 1));
#	Line 1072 | Line 1171 | public class ConcurrentHashMap8Test exte
1171		r = ConcurrentHashMap.ForkJoinTasks.searchEntries
1172		(m, (Map.Entry<Long,Long> e) -> e.getKey().longValue() == (long)(SIZE/2)? e.getKey() : null).invoke();
1173		assertEquals((long)r, (long)(SIZE/2));
1174	<	}
1174	>	}
1175		}

Diff Legend

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