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.5 by jsr166, Fri Mar 22 18:09:52 2013 UTC vs.
Revision 1.6 by dl, Thu Apr 11 19:15:20 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		*/

Diff Legend

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