ViewVC Help

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

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

Comparing jsr166/src/test/tck/CopyOnWriteArraySetTest.java (file contents):
Revision 1.1 by dl, Sun Aug 31 19:24:54 2003 UTC vs.
Revision 1.28 by jsr166, Wed Dec 31 19:05:42 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
2	>	* Written by Doug Lea with assistance from members of JCP JSR-166
3	>	* Expert Group and released to the public domain, as explained at
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9	<	import junit.framework.*;
10	<	import java.util.*;
11	<	import java.util.concurrent.*;
9	>	import java.util.ArrayList;
10	>	import java.util.Arrays;
11	>	import java.util.Collection;
12	>	import java.util.Collections;
13	>	import java.util.Iterator;
14	>	import java.util.NoSuchElementException;
15	>	import java.util.Set;
16	>	import java.util.Vector;
17	>	import java.util.concurrent.CopyOnWriteArraySet;
18
19	<	public class CopyOnWriteArraySetTest extends TestCase{
20	<
19	>	import junit.framework.Test;
20	>	import junit.framework.TestSuite;
21	>
22	>	public class CopyOnWriteArraySetTest extends JSR166TestCase {
23		public static void main(String[] args) {
24	<	junit.textui.TestRunner.run (suite());
24	>	junit.textui.TestRunner.run(suite());
25		}
17	–
26		public static Test suite() {
27	<	return new TestSuite(CopyOnWriteArraySetTest.class);
27	>	return new TestSuite(CopyOnWriteArraySetTest.class);
28		}
29
30	<	static CopyOnWriteArraySet fullSet(int n){
31	<	CopyOnWriteArraySet a = new CopyOnWriteArraySet();
30	>	static CopyOnWriteArraySet<Integer> populatedSet(int n) {
31	>	CopyOnWriteArraySet<Integer> a = new CopyOnWriteArraySet<Integer>();
32		assertTrue(a.isEmpty());
33	<	for (int i = 0; i < n; ++i)
34	<	a.add(new Integer(i));
33	>	for (int i = 0; i < n; i++)
34	>	a.add(i);
35		assertFalse(a.isEmpty());
36		assertEquals(n, a.size());
37		return a;
38		}
39
40	+	static CopyOnWriteArraySet populatedSet(Integer[] elements) {
41	+	CopyOnWriteArraySet<Integer> a = new CopyOnWriteArraySet<Integer>();
42	+	assertTrue(a.isEmpty());
43	+	for (int i = 0; i < elements.length; i++)
44	+	a.add(elements[i]);
45	+	assertFalse(a.isEmpty());
46	+	assertEquals(elements.length, a.size());
47	+	return a;
48	+	}
49	+
50	+	/**
51	+	* Default-constructed set is empty
52	+	*/
53	+	public void testConstructor() {
54	+	CopyOnWriteArraySet a = new CopyOnWriteArraySet();
55	+	assertTrue(a.isEmpty());
56	+	}
57	+
58	+	/**
59	+	* Collection-constructed set holds all of its elements
60	+	*/
61	+	public void testConstructor3() {
62	+	Integer[] ints = new Integer[SIZE];
63	+	for (int i = 0; i < SIZE-1; ++i)
64	+	ints[i] = new Integer(i);
65	+	CopyOnWriteArraySet a = new CopyOnWriteArraySet(Arrays.asList(ints));
66	+	for (int i = 0; i < SIZE; ++i)
67	+	assertTrue(a.contains(ints[i]));
68	+	}
69	+
70		/**
71	<	*  Test to verify addAll correctly adds each element from the given collection
71	>	* addAll adds each element from the given collection
72		*/
73	<	public void testAddAll(){
74	<	CopyOnWriteArraySet full = fullSet(3);
75	<	Vector v = new Vector();
76	<	v.add(new Integer(3));
77	<	v.add(new Integer(4));
78	<	v.add(new Integer(5));
79	<	full.addAll(v);
80	<	assertEquals(6, full.size());
73	>	public void testAddAll() {
74	>	CopyOnWriteArraySet full = populatedSet(3);
75	>	Vector v = new Vector();
76	>	v.add(three);
77	>	v.add(four);
78	>	v.add(five);
79	>	full.addAll(v);
80	>	assertEquals(6, full.size());
81		}
82
83		/**
84	<	*  Test to verify addAllAbsent adds each element from the given collection that did not
85	<	*  already exist in the List
84	>	* addAll adds each element from the given collection that did not
85	>	* already exist in the set
86		*/
87	<	public void testAddAll2(){
88	<	CopyOnWriteArraySet full = fullSet(3);
89	<	Vector v = new Vector();
90	<	v.add(new Integer(3));
91	<	v.add(new Integer(4));
92	<	v.add(new Integer(1)); // will not add this element
93	<	full.addAll(v);
94	<	assertEquals(5, full.size());
87	>	public void testAddAll2() {
88	>	CopyOnWriteArraySet full = populatedSet(3);
89	>	Vector v = new Vector();
90	>	v.add(three);
91	>	v.add(four);
92	>	v.add(one); // will not add this element
93	>	full.addAll(v);
94	>	assertEquals(5, full.size());
95		}
96
97		/**
98	<	*  Test to verify addIfAbsent will not add the element if it already exists in the list
98	>	* add will not add the element if it already exists in the set
99		*/
100	<	public void testAdd2(){
101	<	CopyOnWriteArraySet full = fullSet(3);
102	<	full.add(new Integer(1));
103	<	assertEquals(3, full.size());
100	>	public void testAdd2() {
101	>	CopyOnWriteArraySet full = populatedSet(3);
102	>	full.add(one);
103	>	assertEquals(3, full.size());
104		}
105
106		/**
107	<	*  test to verify addIfAbsent correctly adds the element when it does not exist in the list
107	>	* add adds the element when it does not exist in the set
108		*/
109	<	public void testAdd3(){
110	<	CopyOnWriteArraySet full = fullSet(3);
111	<	full.add(new Integer(3));
112	<	assertTrue(full.contains(new Integer(3)));
109	>	public void testAdd3() {
110	>	CopyOnWriteArraySet full = populatedSet(3);
111	>	full.add(three);
112	>	assertTrue(full.contains(three));
113		}
114
115		/**
116	<	*  Test to verify clear correctly removes all elements from the list
116	>	* clear removes all elements from the set
117		*/
118	<	public void testClear(){
119	<	CopyOnWriteArraySet full = fullSet(3);
120	<	full.clear();
121	<	assertEquals(0, full.size());
118	>	public void testClear() {
119	>	CopyOnWriteArraySet full = populatedSet(3);
120	>	full.clear();
121	>	assertEquals(0, full.size());
122		}
123
124		/**
125	<	*  Test to verify contains returns the correct values
125	>	* contains returns true for added elements
126		*/
127	<	public void testContains(){
128	<	CopyOnWriteArraySet full = fullSet(3);
129	<	assertTrue(full.contains(new Integer(1)));
130	<	assertFalse(full.contains(new Integer(5)));
127	>	public void testContains() {
128	>	CopyOnWriteArraySet full = populatedSet(3);
129	>	assertTrue(full.contains(one));
130	>	assertFalse(full.contains(five));
131		}
132
133	+	/**
134	+	* Sets with equal elements are equal
135	+	*/
136		public void testEquals() {
137	<	CopyOnWriteArraySet a = fullSet(3);
138	<	CopyOnWriteArraySet b = fullSet(3);
137	>	CopyOnWriteArraySet a = populatedSet(3);
138	>	CopyOnWriteArraySet b = populatedSet(3);
139		assertTrue(a.equals(b));
140		assertTrue(b.equals(a));
141		assertEquals(a.hashCode(), b.hashCode());
142	<	a.add(new Integer(-1));
142	>	a.add(m1);
143		assertFalse(a.equals(b));
144		assertFalse(b.equals(a));
145	<	b.add(new Integer(-1));
145	>	b.add(m1);
146		assertTrue(a.equals(b));
147		assertTrue(b.equals(a));
148		assertEquals(a.hashCode(), b.hashCode());
149		}
150
110	–
151		/**
152	<	*  Test to verify containsAll returns the correct values
152	>	* containsAll returns true for collections with subset of elements
153		*/
154	<	public void testContainsAll(){
155	<	CopyOnWriteArraySet full = fullSet(3);
156	<	Vector v = new Vector();
157	<	v.add(new Integer(1));
158	<	v.add(new Integer(2));
159	<	assertTrue(full.containsAll(v));
160	<	v.add(new Integer(6));
161	<	assertFalse(full.containsAll(v));
154	>	public void testContainsAll() {
155	>	CopyOnWriteArraySet full = populatedSet(3);
156	>	Vector v = new Vector();
157	>	v.add(one);
158	>	v.add(two);
159	>	assertTrue(full.containsAll(v));
160	>	v.add(six);
161	>	assertFalse(full.containsAll(v));
162		}
163
164		/**
165	<	*  Test to verify isEmpty returns the correct values
165	>	* isEmpty is true when empty, else false
166		*/
167	<	public void testIsEmpty(){
168	<	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
169	<	CopyOnWriteArraySet full = fullSet(3);
170	<	assertTrue(empty.isEmpty());
171	<	assertFalse(full.isEmpty());
167	>	public void testIsEmpty() {
168	>	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
169	>	CopyOnWriteArraySet full = populatedSet(3);
170	>	assertTrue(empty.isEmpty());
171	>	assertFalse(full.isEmpty());
172		}
173
174		/**
175	<	*  Test to verify iterator() returns an iterator containing the elements of the list
175	>	* iterator() returns an iterator containing the elements of the
176	>	* set in insertion order
177		*/
178	<	public void testIterator(){
179	<	CopyOnWriteArraySet full = fullSet(3);
180	<	Iterator i = full.iterator();
181	<	int j;
182	<	for(j = 0; i.hasNext(); j++)
183	<	assertEquals(j, ((Integer)i.next()).intValue());
184	<	assertEquals(3, j);
178	>	public void testIterator() {
179	>	Collection empty = new CopyOnWriteArraySet();
180	>	assertFalse(empty.iterator().hasNext());
181	>	try {
182	>	empty.iterator().next();
183	>	shouldThrow();
184	>	} catch (NoSuchElementException success) {}
185	>
186	>	Integer[] elements = new Integer[SIZE];
187	>	for (int i = 0; i < SIZE; i++)
188	>	elements[i] = i;
189	>	Collections.shuffle(Arrays.asList(elements));
190	>	Collection<Integer> full = populatedSet(elements);
191	>
192	>	Iterator it = full.iterator();
193	>	for (int j = 0; j < SIZE; j++) {
194	>	assertTrue(it.hasNext());
195	>	assertEquals(elements[j], it.next());
196	>	}
197	>	assertFalse(it.hasNext());
198	>	try {
199	>	it.next();
200	>	shouldThrow();
201	>	} catch (NoSuchElementException success) {}
202		}
203
204	<	public void testIteratorRemove () {
205	<	CopyOnWriteArraySet full = fullSet(3);
204	>	/**
205	>	* iterator remove is unsupported
206	>	*/
207	>	public void testIteratorRemove() {
208	>	CopyOnWriteArraySet full = populatedSet(3);
209		Iterator it = full.iterator();
210		it.next();
211		try {
212		it.remove();
213	<	fail("should throw");
214	<	}
154	<	catch (UnsupportedOperationException success) {}
213	>	shouldThrow();
214	>	} catch (UnsupportedOperationException success) {}
215		}
216
217	<	public void testToString(){
218	<	CopyOnWriteArraySet full = fullSet(3);
217	>	/**
218	>	* toString holds toString of elements
219	>	*/
220	>	public void testToString() {
221	>	assertEquals("[]", new CopyOnWriteArraySet().toString());
222	>	CopyOnWriteArraySet full = populatedSet(3);
223		String s = full.toString();
224	<	for (int i = 0; i < 3; ++i) {
225	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
226	<	}
227	<	}
228	<
224	>	for (int i = 0; i < 3; ++i)
225	>	assertTrue(s.contains(String.valueOf(i)));
226	>	assertEquals(new ArrayList(full).toString(),
227	>	full.toString());
228	>	}
229
230		/**
231	<	*  Test to verify removeAll correctly removes all elements from the given collection
231	>	* removeAll removes all elements from the given collection
232		*/
233	<	public void testRemoveAll(){
234	<	CopyOnWriteArraySet full = fullSet(3);
235	<	Vector v = new Vector();
236	<	v.add(new Integer(1));
237	<	v.add(new Integer(2));
238	<	full.removeAll(v);
239	<	assertEquals(1, full.size());
233	>	public void testRemoveAll() {
234	>	CopyOnWriteArraySet full = populatedSet(3);
235	>	Vector v = new Vector();
236	>	v.add(one);
237	>	v.add(two);
238	>	full.removeAll(v);
239	>	assertEquals(1, full.size());
240		}
241
242	<
243	<	public void testRemove(){
244	<	CopyOnWriteArraySet full = fullSet(3);
245	<	full.remove(new Integer(1));
246	<	assertFalse(full.contains(new Integer(1)));
247	<	assertEquals(2, full.size());
242	>	/**
243	>	* remove removes an element
244	>	*/
245	>	public void testRemove() {
246	>	CopyOnWriteArraySet full = populatedSet(3);
247	>	full.remove(one);
248	>	assertFalse(full.contains(one));
249	>	assertEquals(2, full.size());
250		}
251
252		/**
253	<	*  Test to verify size returns the correct values
253	>	* size returns the number of elements
254		*/
255	<	public void testSize(){
256	<	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
257	<	CopyOnWriteArraySet full = fullSet(3);
258	<	assertEquals(3, full.size());
259	<	assertEquals(0, empty.size());
255	>	public void testSize() {
256	>	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
257	>	CopyOnWriteArraySet full = populatedSet(3);
258	>	assertEquals(3, full.size());
259	>	assertEquals(0, empty.size());
260		}
261
262		/**
263	<	*  Test to verify toArray returns an Object array containing all elements from the list
263	>	* toArray() returns an Object array containing all elements from
264	>	* the set in insertion order
265		*/
266	<	public void testToArray(){
267	<	CopyOnWriteArraySet full = fullSet(3);
268	<	Object[] o = full.toArray();
269	<	assertEquals(3, o.length);
270	<	assertEquals(0, ((Integer)o[0]).intValue());
271	<	assertEquals(1, ((Integer)o[1]).intValue());
272	<	assertEquals(2, ((Integer)o[2]).intValue());
266	>	public void testToArray() {
267	>	Object[] a = new CopyOnWriteArraySet().toArray();
268	>	assertTrue(Arrays.equals(new Object[0], a));
269	>	assertSame(Object[].class, a.getClass());
270	>
271	>	Integer[] elements = new Integer[SIZE];
272	>	for (int i = 0; i < SIZE; i++)
273	>	elements[i] = i;
274	>	Collections.shuffle(Arrays.asList(elements));
275	>	Collection<Integer> full = populatedSet(elements);
276	>
277	>	assertTrue(Arrays.equals(elements, full.toArray()));
278	>	assertSame(Object[].class, full.toArray().getClass());
279		}
280
281		/**
282	<	*  test to verify toArray returns an Integer array containing all elements from the list
282	>	* toArray(Integer array) returns an Integer array containing all
283	>	* elements from the set in insertion order
284		*/
285	<	public void testToArray2(){
286	<	CopyOnWriteArraySet full = fullSet(3);
287	<	Integer[] i = new Integer[3];
288	<	i = (Integer[])full.toArray(i);
289	<	assertEquals(3, i.length);
290	<	assertEquals(0, i[0].intValue());
291	<	assertEquals(1, i[1].intValue());
292	<	assertEquals(2, i[2].intValue());
293	<	}
285	>	public void testToArray2() {
286	>	Collection empty = new CopyOnWriteArraySet();
287	>	Integer[] a;
288	>
289	>	a = new Integer[0];
290	>	assertSame(a, empty.toArray(a));
291	>
292	>	a = new Integer[SIZE/2];
293	>	Arrays.fill(a, 42);
294	>	assertSame(a, empty.toArray(a));
295	>	assertNull(a[0]);
296	>	for (int i = 1; i < a.length; i++)
297	>	assertEquals(42, (int) a[i]);
298
299	+	Integer[] elements = new Integer[SIZE];
300	+	for (int i = 0; i < SIZE; i++)
301	+	elements[i] = i;
302	+	Collections.shuffle(Arrays.asList(elements));
303	+	Collection<Integer> full = populatedSet(elements);
304
305	+	Arrays.fill(a, 42);
306	+	assertTrue(Arrays.equals(elements, full.toArray(a)));
307	+	for (int i = 0; i < a.length; i++)
308	+	assertEquals(42, (int) a[i]);
309	+	assertSame(Integer[].class, full.toArray(a).getClass());
310
311	<	// Exception tests
311	>	a = new Integer[SIZE];
312	>	Arrays.fill(a, 42);
313	>	assertSame(a, full.toArray(a));
314	>	assertTrue(Arrays.equals(elements, a));
315	>
316	>	a = new Integer[2*SIZE];
317	>	Arrays.fill(a, 42);
318	>	assertSame(a, full.toArray(a));
319	>	assertTrue(Arrays.equals(elements, Arrays.copyOf(a, SIZE)));
320	>	assertNull(a[SIZE]);
321	>	for (int i = SIZE + 1; i < a.length; i++)
322	>	assertEquals(42, (int) a[i]);
323	>	}
324
325		/**
326	<	*  Test to verify toArray throws an ArrayStoreException when the given array
327	<	*  can not store the objects inside the list
326	>	* toArray throws an ArrayStoreException when the given array can
327	>	* not store the objects inside the set
328		*/
329	<	public void testToArray_ArrayStoreException(){
330	<	try{
329	>	public void testToArray_ArrayStoreException() {
330	>	try {
331		CopyOnWriteArraySet c = new CopyOnWriteArraySet();
332		c.add("zfasdfsdf");
333		c.add("asdadasd");
334		c.toArray(new Long[5]);
335	<	fail("Object[] toArray(Object[]) should throw ArrayStoreException");
336	<	}catch(ArrayStoreException e){}
335	>	shouldThrow();
336	>	} catch (ArrayStoreException success) {}
337	>	}
338	>
339	>	/**
340	>	* A deserialized serialized set is equal
341	>	*/
342	>	public void testSerialization() throws Exception {
343	>	Set x = populatedSet(SIZE);
344	>	Set y = serialClone(x);
345	>
346	>	assertNotSame(y, x);
347	>	assertEquals(x.size(), y.size());
348	>	assertEquals(x.toString(), y.toString());
349	>	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
350	>	assertEquals(x, y);
351	>	assertEquals(y, x);
352	>	}
353	>
354	>	/**
355	>	* addAll is idempotent
356	>	*/
357	>	public void testAddAll_idempotent() throws Exception {
358	>	Set x = populatedSet(SIZE);
359	>	Set y = new CopyOnWriteArraySet(x);
360	>	y.addAll(x);
361	>	assertEquals(x, y);
362	>	assertEquals(y, x);
363		}
364
365		}

Diff Legend

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