ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ConcurrentHashMapTest.java

Comparing jsr166/src/test/tck/ConcurrentHashMapTest.java (file contents):
Revision 1.25 by jsr166, Tue May 31 16:16:23 2011 UTC vs.
Revision 1.32 by jsr166, Wed Jun 12 18:09:00 2013 UTC

#	Line 19 | Line 19 | public class ConcurrentHashMapTest exten
19		}
20
21		/**
22	<	* Create a map from Integers 1-5 to Strings "A"-"E".
22	>	* Returns a new map from Integers 1-5 to Strings "A"-"E".
23		*/
24		private static ConcurrentHashMap map5() {
25		ConcurrentHashMap map = new ConcurrentHashMap(5);
#	Line 34 | Line 34 | public class ConcurrentHashMapTest exten
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 =
88	+	new ConcurrentHashMap<BI, Boolean>();
89	+	for (int i = 0; i < 1000; i++) {
90	+	assertTrue(m.put(new CI(i), true) == null);
91	+	}
92	+	for (int i = 0; i < 1000; i++) {
93	+	assertTrue(m.containsKey(new CI(i)));
94	+	assertTrue(m.containsKey(new DI(i)));
95	+	}
96	+	}
97	+
98	+	/**
99	+	* Elements of classes with erased generic type parameters based
100	+	* on Comparable can be inserted and found.
101	+	*/
102	+	public void testGenericComparable() {
103	+	ConcurrentHashMap<Object, Boolean> m =
104	+	new ConcurrentHashMap<Object, Boolean>();
105	+	for (int i = 0; i < 1000; i++) {
106	+	BI bi = new BI(i);
107	+	BS bs = new BS(String.valueOf(i));
108	+	LexicographicList<BI> bis = new LexicographicList<BI>(bi);
109	+	LexicographicList<BS> bss = new LexicographicList<BS>(bs);
110	+	assertTrue(m.putIfAbsent(bis, true) == null);
111	+	assertTrue(m.containsKey(bis));
112	+	if (m.putIfAbsent(bss, true) == null)
113	+	assertTrue(m.containsKey(bss));
114	+	assertTrue(m.containsKey(bis));
115	+	}
116	+	for (int i = 0; i < 1000; i++) {
117	+	assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
118	+	}
119	+	}
120	+
121	+	/**
122	+	* Elements of non-comparable classes equal to those of classes
123	+	* with erased generic type parameters based on Comparable can be
124	+	* inserted and found.
125	+	*/
126	+	public void testGenericComparable2() {
127	+	ConcurrentHashMap<Object, Boolean> m =
128	+	new ConcurrentHashMap<Object, Boolean>();
129	+	for (int i = 0; i < 1000; i++) {
130	+	m.put(new ArrayList(Collections.singleton(new BI(i))), true);
131	+	}
132	+
133	+	for (int i = 0; i < 1000; i++) {
134	+	LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
135	+	assertTrue(m.containsKey(bis));
136	+	}
137	+	}
138	+
139		/**
140		* clear removes all pairs
141		*/
142		public void testClear() {
143		ConcurrentHashMap map = map5();
144		map.clear();
145	<	assertEquals(map.size(), 0);
145	>	assertEquals(0, map.size());
146		}
147
148		/**
#	Line 552 | Line 654 | public class ConcurrentHashMapTest exten
654		Map x = map5();
655		Map y = serialClone(x);
656
657	<	assertTrue(x != y);
657	>	assertNotSame(x, y);
658		assertEquals(x.size(), y.size());
659		assertEquals(x, y);
660		assertEquals(y, x);
#	Line 569 | Line 671 | public class ConcurrentHashMapTest exten
671		map.put(new Integer(i), new Integer(i));
672		assertFalse(map.isEmpty());
673		Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next();
674	<
675	<	// assert that entry1 is not 16
676	<	assertTrue("entry is 16, test not valid",
677	<	!entry1.getKey().equals(new Integer(16)));
678	<
679	<	// remove 16 (a different key) from map
680	<	// which just happens to cause entry1 to be cloned in map
681	<	map.remove(new Integer(16));
682	<	entry1.setValue("XYZ");
581	<	assertTrue(map.containsValue("XYZ")); // fails
674	>	// Unless it happens to be first (in which case remainder of
675	>	// test is skipped), remove a possibly-colliding key from map
676	>	// which, under some implementations, may cause entry1 to be
677	>	// cloned in map
678	>	if (!entry1.getKey().equals(new Integer(16))) {
679	>	map.remove(new Integer(16));
680	>	entry1.setValue("XYZ");
681	>	assertTrue(map.containsValue("XYZ")); // fails if write-through broken
682	>	}
683		}
684
685		}

Diff Legend

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