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.11 by jsr166, Sat Nov 21 02:07:26 2009 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/licenses/publicdomain
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 11 | Line 12 | import java.util.concurrent.*;
12		import java.io.*;
13
14		public class CopyOnWriteArraySetTest extends JSR166TestCase {
14	–
15		public static void main(String[] args) {
16	<	junit.textui.TestRunner.run (suite());
16	>	junit.textui.TestRunner.run (suite());
17		}
18	–
18		public static Test suite() {
19	<	return new TestSuite(CopyOnWriteArraySetTest.class);
19	>	return new TestSuite(CopyOnWriteArraySetTest.class);
20		}
21
22	<	static CopyOnWriteArraySet populatedSet(int n){
23	<	CopyOnWriteArraySet a = new CopyOnWriteArraySet();
22	>	static CopyOnWriteArraySet populatedSet(int n) {
23	>	CopyOnWriteArraySet a = new CopyOnWriteArraySet();
24		assertTrue(a.isEmpty());
25	<	for (int i = 0; i < n; ++i)
25	>	for (int i = 0; i < n; ++i)
26		a.add(new Integer(i));
27		assertFalse(a.isEmpty());
28		assertEquals(n, a.size());
29		return a;
30		}
31
32	+	/**
33	+	* Default-constructed set is empty
34	+	*/
35		public void testConstructor() {
36	<	CopyOnWriteArraySet a = new CopyOnWriteArraySet();
36	>	CopyOnWriteArraySet a = new CopyOnWriteArraySet();
37		assertTrue(a.isEmpty());
38		}
39
40	+	/**
41	+	* Collection-constructed set holds all of its elements
42	+	*/
43		public void testConstructor3() {
44		Integer[] ints = new Integer[SIZE];
45		for (int i = 0; i < SIZE-1; ++i)
46		ints[i] = new Integer(i);
47	<	CopyOnWriteArraySet a = new CopyOnWriteArraySet(Arrays.asList(ints));
48	<	for (int i = 0; i < SIZE; ++i)
47	>	CopyOnWriteArraySet a = new CopyOnWriteArraySet(Arrays.asList(ints));
48	>	for (int i = 0; i < SIZE; ++i)
49		assertTrue(a.contains(ints[i]));
50		}
51	<
51	>
52
53		/**
54	<	*   addAll correctly adds each element from the given collection
54	>	*   addAll  adds each element from the given collection
55		*/
56	<	public void testAddAll(){
57	<	CopyOnWriteArraySet full = populatedSet(3);
58	<	Vector v = new Vector();
59	<	v.add(three);
60	<	v.add(four);
61	<	v.add(five);
62	<	full.addAll(v);
63	<	assertEquals(6, full.size());
56	>	public void testAddAll() {
57	>	CopyOnWriteArraySet full = populatedSet(3);
58	>	Vector v = new Vector();
59	>	v.add(three);
60	>	v.add(four);
61	>	v.add(five);
62	>	full.addAll(v);
63	>	assertEquals(6, full.size());
64		}
65
66		/**
67	<	*   addAllAbsent adds each element from the given collection that did not
68	<	*  already exist in the List
67	>	*   addAll adds each element from the given collection that did not
68	>	*  already exist in the set
69		*/
70	<	public void testAddAll2(){
71	<	CopyOnWriteArraySet full = populatedSet(3);
72	<	Vector v = new Vector();
73	<	v.add(three);
74	<	v.add(four);
75	<	v.add(one); // will not add this element
76	<	full.addAll(v);
77	<	assertEquals(5, full.size());
70	>	public void testAddAll2() {
71	>	CopyOnWriteArraySet full = populatedSet(3);
72	>	Vector v = new Vector();
73	>	v.add(three);
74	>	v.add(four);
75	>	v.add(one); // will not add this element
76	>	full.addAll(v);
77	>	assertEquals(5, full.size());
78		}
79
80		/**
81	<	*   addIfAbsent will not add the element if it already exists in the list
81	>	*   add will not add the element if it already exists in the set
82		*/
83	<	public void testAdd2(){
84	<	CopyOnWriteArraySet full = populatedSet(3);
85	<	full.add(one);
86	<	assertEquals(3, full.size());
83	>	public void testAdd2() {
84	>	CopyOnWriteArraySet full = populatedSet(3);
85	>	full.add(one);
86	>	assertEquals(3, full.size());
87		}
88
89		/**
90	<	*   addIfAbsent correctly adds the element when it does not exist in the list
90	>	*   add  adds the element when it does not exist
91	>	*   in the set
92		*/
93	<	public void testAdd3(){
94	<	CopyOnWriteArraySet full = populatedSet(3);
93	>	public void testAdd3() {
94	>	CopyOnWriteArraySet full = populatedSet(3);
95		full.add(three);
96		assertTrue(full.contains(three));
97		}
98
99		/**
100	<	*   clear correctly removes all elements from the list
100	>	*   clear  removes all elements from the set
101		*/
102	<	public void testClear(){
103	<	CopyOnWriteArraySet full = populatedSet(3);
104	<	full.clear();
105	<	assertEquals(0, full.size());
102	>	public void testClear() {
103	>	CopyOnWriteArraySet full = populatedSet(3);
104	>	full.clear();
105	>	assertEquals(0, full.size());
106		}
107
108		/**
109	<	*   contains returns the correct values
109	>	*   contains returns true for added elements
110		*/
111	<	public void testContains(){
112	<	CopyOnWriteArraySet full = populatedSet(3);
113	<	assertTrue(full.contains(one));
114	<	assertFalse(full.contains(five));
111	>	public void testContains() {
112	>	CopyOnWriteArraySet full = populatedSet(3);
113	>	assertTrue(full.contains(one));
114	>	assertFalse(full.contains(five));
115		}
116
117	+	/**
118	+	* Sets with equal elements are equal
119	+	*/
120		public void testEquals() {
121	<	CopyOnWriteArraySet a = populatedSet(3);
122	<	CopyOnWriteArraySet b = populatedSet(3);
121	>	CopyOnWriteArraySet a = populatedSet(3);
122	>	CopyOnWriteArraySet b = populatedSet(3);
123		assertTrue(a.equals(b));
124		assertTrue(b.equals(a));
125		assertEquals(a.hashCode(), b.hashCode());
#	Line 123 | Line 132 | public class CopyOnWriteArraySetTest ext
132		assertEquals(a.hashCode(), b.hashCode());
133		}
134
135	<
135	>
136		/**
137	<	*   containsAll returns the correct values
137	>	*   containsAll returns true for collections with subset of elements
138		*/
139	<	public void testContainsAll(){
140	<	CopyOnWriteArraySet full = populatedSet(3);
141	<	Vector v = new Vector();
142	<	v.add(one);
143	<	v.add(two);
144	<	assertTrue(full.containsAll(v));
145	<	v.add(six);
146	<	assertFalse(full.containsAll(v));
139	>	public void testContainsAll() {
140	>	CopyOnWriteArraySet full = populatedSet(3);
141	>	Vector v = new Vector();
142	>	v.add(one);
143	>	v.add(two);
144	>	assertTrue(full.containsAll(v));
145	>	v.add(six);
146	>	assertFalse(full.containsAll(v));
147		}
148
149		/**
150	<	*   isEmpty returns the correct values
150	>	*   isEmpty is true when empty, else false
151		*/
152	<	public void testIsEmpty(){
153	<	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
154	<	CopyOnWriteArraySet full = populatedSet(3);
155	<	assertTrue(empty.isEmpty());
156	<	assertFalse(full.isEmpty());
152	>	public void testIsEmpty() {
153	>	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
154	>	CopyOnWriteArraySet full = populatedSet(3);
155	>	assertTrue(empty.isEmpty());
156	>	assertFalse(full.isEmpty());
157		}
158
159		/**
160	<	*   iterator() returns an iterator containing the elements of the list
160	>	*   iterator() returns an iterator containing the elements of the set
161		*/
162	<	public void testIterator(){
163	<	CopyOnWriteArraySet full = populatedSet(3);
164	<	Iterator i = full.iterator();
165	<	int j;
166	<	for(j = 0; i.hasNext(); j++)
167	<	assertEquals(j, ((Integer)i.next()).intValue());
168	<	assertEquals(3, j);
162	>	public void testIterator() {
163	>	CopyOnWriteArraySet full = populatedSet(3);
164	>	Iterator i = full.iterator();
165	>	int j;
166	>	for (j = 0; i.hasNext(); j++)
167	>	assertEquals(j, ((Integer)i.next()).intValue());
168	>	assertEquals(3, j);
169		}
170
171	+	/**
172	+	* iterator remove is unsupported
173	+	*/
174		public void testIteratorRemove () {
175	<	CopyOnWriteArraySet full = populatedSet(3);
175	>	CopyOnWriteArraySet full = populatedSet(3);
176		Iterator it = full.iterator();
177		it.next();
178		try {
179		it.remove();
180	<	fail("should throw");
180	>	shouldThrow();
181		}
182		catch (UnsupportedOperationException success) {}
183		}
184
185	<	public void testToString(){
186	<	CopyOnWriteArraySet full = populatedSet(3);
185	>	/**
186	>	* toString holds toString of elements
187	>	*/
188	>	public void testToString() {
189	>	CopyOnWriteArraySet full = populatedSet(3);
190		String s = full.toString();
191		for (int i = 0; i < 3; ++i) {
192		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
193		}
194	<	}
194	>	}
195
196
197		/**
198	<	*   removeAll correctly removes all elements from the given collection
198	>	*   removeAll  removes all elements from the given collection
199		*/
200	<	public void testRemoveAll(){
201	<	CopyOnWriteArraySet full = populatedSet(3);
202	<	Vector v = new Vector();
203	<	v.add(one);
204	<	v.add(two);
205	<	full.removeAll(v);
206	<	assertEquals(1, full.size());
200	>	public void testRemoveAll() {
201	>	CopyOnWriteArraySet full = populatedSet(3);
202	>	Vector v = new Vector();
203	>	v.add(one);
204	>	v.add(two);
205	>	full.removeAll(v);
206	>	assertEquals(1, full.size());
207		}
208
209
210	<	public void testRemove(){
211	<	CopyOnWriteArraySet full = populatedSet(3);
212	<	full.remove(one);
210	>	/**
211	>	* remove removes an element
212	>	*/
213	>	public void testRemove() {
214	>	CopyOnWriteArraySet full = populatedSet(3);
215	>	full.remove(one);
216		assertFalse(full.contains(one));
217	<	assertEquals(2, full.size());
217	>	assertEquals(2, full.size());
218		}
219
220		/**
221	<	*   size returns the correct values
221	>	*   size returns the number of elements
222		*/
223	<	public void testSize(){
224	<	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
225	<	CopyOnWriteArraySet full = populatedSet(3);
226	<	assertEquals(3, full.size());
227	<	assertEquals(0, empty.size());
223	>	public void testSize() {
224	>	CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
225	>	CopyOnWriteArraySet full = populatedSet(3);
226	>	assertEquals(3, full.size());
227	>	assertEquals(0, empty.size());
228		}
229
230		/**
231	<	*   toArray returns an Object array containing all elements from the list
231	>	*   toArray returns an Object array containing all elements from the set
232		*/
233	<	public void testToArray(){
234	<	CopyOnWriteArraySet full = populatedSet(3);
235	<	Object[] o = full.toArray();
236	<	assertEquals(3, o.length);
237	<	assertEquals(0, ((Integer)o[0]).intValue());
238	<	assertEquals(1, ((Integer)o[1]).intValue());
239	<	assertEquals(2, ((Integer)o[2]).intValue());
233	>	public void testToArray() {
234	>	CopyOnWriteArraySet full = populatedSet(3);
235	>	Object[] o = full.toArray();
236	>	assertEquals(3, o.length);
237	>	assertEquals(0, ((Integer)o[0]).intValue());
238	>	assertEquals(1, ((Integer)o[1]).intValue());
239	>	assertEquals(2, ((Integer)o[2]).intValue());
240		}
241
242		/**
243	<	*   toArray returns an Integer array containing all elements from the list
243	>	*   toArray returns an Integer array containing all elements from
244	>	*   the set
245		*/
246	<	public void testToArray2(){
247	<	CopyOnWriteArraySet full = populatedSet(3);
248	<	Integer[] i = new Integer[3];
249	<	i = (Integer[])full.toArray(i);
250	<	assertEquals(3, i.length);
251	<	assertEquals(0, i[0].intValue());
252	<	assertEquals(1, i[1].intValue());
253	<	assertEquals(2, i[2].intValue());
246	>	public void testToArray2() {
247	>	CopyOnWriteArraySet full = populatedSet(3);
248	>	Integer[] i = new Integer[3];
249	>	i = (Integer[])full.toArray(i);
250	>	assertEquals(3, i.length);
251	>	assertEquals(0, i[0].intValue());
252	>	assertEquals(1, i[1].intValue());
253	>	assertEquals(2, i[2].intValue());
254		}
255
256
238	–
239	–	// Exception tests
240	–
257		/**
258	<	*   toArray throws an ArrayStoreException when the given array
259	<	*  can not store the objects inside the list
258	>	*  toArray throws an ArrayStoreException when the given array can
259	>	*  not store the objects inside the set
260		*/
261	<	public void testToArray_ArrayStoreException(){
262	<	try{
261	>	public void testToArray_ArrayStoreException() {
262	>	try {
263		CopyOnWriteArraySet c = new CopyOnWriteArraySet();
264		c.add("zfasdfsdf");
265		c.add("asdadasd");
266		c.toArray(new Long[5]);
267	<	fail("Object[] toArray(Object[]) should throw ArrayStoreException");
268	<	}catch(ArrayStoreException e){}
267	>	shouldThrow();
268	>	} catch (ArrayStoreException e) {}
269		}
270
271	+	/**
272	+	* A deserialized serialized set is equal
273	+	*/
274		public void testSerialization() {
275		CopyOnWriteArraySet q = populatedSet(SIZE);
276
#	Line 267 | Line 286 | public class CopyOnWriteArraySetTest ext
286		assertEquals(q.size(), r.size());
287		assertTrue(q.equals(r));
288		assertTrue(r.equals(q));
289	<	} catch(Exception e){
290	<	e.printStackTrace();
272	<	fail("unexpected exception");
289	>	} catch (Exception e) {
290	>	unexpectedException();
291		}
292		}
293

Diff Legend

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