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

Diff Legend

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