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.2 by dl, Sun Sep 7 20:39:11 2003 UTC vs.
Revision 1.7 by dl, Mon Dec 29 19:05:40 2003 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 10 | Line 11 | import java.util.*;
11		import java.util.concurrent.*;
12		import java.io.*;
13
14	<	public class CopyOnWriteArraySetTest extends TestCase{
14	<
14	>	public class CopyOnWriteArraySetTest extends JSR166TestCase {
15		public static void main(String[] args) {
16		junit.textui.TestRunner.run (suite());
17		}
18	–
18		public static Test suite() {
19		return new TestSuite(CopyOnWriteArraySetTest.class);
20		}
21
22	<	static CopyOnWriteArraySet fullSet(int n){
22	>	static CopyOnWriteArraySet populatedSet(int n){
23		CopyOnWriteArraySet a = new CopyOnWriteArraySet();
24		assertTrue(a.isEmpty());
25		for (int i = 0; i < n; ++i)
#	Line 31 | Line 30 | public class CopyOnWriteArraySetTest ext
30		}
31
32		/**
33	<	*  Test to verify addAll correctly adds each element from the given collection
33	>	* Default-constructed set is empty
34		*/
35	<	public void testAddAll(){
36	<	CopyOnWriteArraySet full = fullSet(3);
35	>	public void testConstructor() {
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)
49	>	assertTrue(a.contains(ints[i]));
50	>	}
51	>
52	>
53	>	/**
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(new Integer(3));
60	<	v.add(new Integer(4));
61	<	v.add(new Integer(5));
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	<	*  Test to verify 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 = fullSet(3);
70	>	public void testAddAll2() {
71	>	CopyOnWriteArraySet full = populatedSet(3);
72		Vector v = new Vector();
73	<	v.add(new Integer(3));
74	<	v.add(new Integer(4));
75	<	v.add(new Integer(1)); // will not add this element
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	<	*  Test to verify 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 = fullSet(3);
85	<	full.add(new Integer(1));
83	>	public void testAdd2() {
84	>	CopyOnWriteArraySet full = populatedSet(3);
85	>	full.add(one);
86		assertEquals(3, full.size());
87		}
88
89		/**
90	<	*  test to verify 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 = fullSet(3);
95	<	full.add(new Integer(3));
96	<	assertTrue(full.contains(new Integer(3)));
93	>	public void testAdd3() {
94	>	CopyOnWriteArraySet full = populatedSet(3);
95	>	full.add(three);
96	>	assertTrue(full.contains(three));
97		}
98
99		/**
100	<	*  Test to verify clear correctly removes all elements from the list
100	>	*   clear  removes all elements from the set
101		*/
102	<	public void testClear(){
103	<	CopyOnWriteArraySet full = fullSet(3);
102	>	public void testClear() {
103	>	CopyOnWriteArraySet full = populatedSet(3);
104		full.clear();
105		assertEquals(0, full.size());
106		}
107
108		/**
109	<	*  Test to verify contains returns the correct values
109	>	*   contains returns true for added elements
110		*/
111	<	public void testContains(){
112	<	CopyOnWriteArraySet full = fullSet(3);
113	<	assertTrue(full.contains(new Integer(1)));
114	<	assertFalse(full.contains(new Integer(5)));
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 = fullSet(3);
122	<	CopyOnWriteArraySet b = fullSet(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());
126	<	a.add(new Integer(-1));
126	>	a.add(m1);
127		assertFalse(a.equals(b));
128		assertFalse(b.equals(a));
129	<	b.add(new Integer(-1));
129	>	b.add(m1);
130		assertTrue(a.equals(b));
131		assertTrue(b.equals(a));
132		assertEquals(a.hashCode(), b.hashCode());
#	Line 110 | Line 134 | public class CopyOnWriteArraySetTest ext
134
135
136		/**
137	<	*  Test to verify containsAll returns the correct values
137	>	*   containsAll returns true for collections with subset of elements
138		*/
139	<	public void testContainsAll(){
140	<	CopyOnWriteArraySet full = fullSet(3);
139	>	public void testContainsAll() {
140	>	CopyOnWriteArraySet full = populatedSet(3);
141		Vector v = new Vector();
142	<	v.add(new Integer(1));
143	<	v.add(new Integer(2));
142	>	v.add(one);
143	>	v.add(two);
144		assertTrue(full.containsAll(v));
145	<	v.add(new Integer(6));
145	>	v.add(six);
146		assertFalse(full.containsAll(v));
147		}
148
149		/**
150	<	*  Test to verify isEmpty returns the correct values
150	>	*   isEmpty is true when empty, else false
151		*/
152	<	public void testIsEmpty(){
152	>	public void testIsEmpty() {
153		CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
154	<	CopyOnWriteArraySet full = fullSet(3);
154	>	CopyOnWriteArraySet full = populatedSet(3);
155		assertTrue(empty.isEmpty());
156		assertFalse(full.isEmpty());
157		}
158
159		/**
160	<	*  Test to verify 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 = fullSet(3);
162	>	public void testIterator() {
163	>	CopyOnWriteArraySet full = populatedSet(3);
164		Iterator i = full.iterator();
165		int j;
166		for(j = 0; i.hasNext(); j++)
#	Line 144 | Line 168 | public class CopyOnWriteArraySetTest ext
168		assertEquals(3, j);
169		}
170
171	+	/**
172	+	* iterator remove is unsupported
173	+	*/
174		public void testIteratorRemove () {
175	<	CopyOnWriteArraySet full = fullSet(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 = fullSet(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);
#	Line 165 | Line 195 | public class CopyOnWriteArraySetTest ext
195
196
197		/**
198	<	*  Test to verify 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 = fullSet(3);
200	>	public void testRemoveAll() {
201	>	CopyOnWriteArraySet full = populatedSet(3);
202		Vector v = new Vector();
203	<	v.add(new Integer(1));
204	<	v.add(new Integer(2));
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 = fullSet(3);
212	<	full.remove(new Integer(1));
213	<	assertFalse(full.contains(new Integer(1)));
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());
218		}
219
220		/**
221	<	*  Test to verify size returns the correct values
221	>	*   size returns the number of elements
222		*/
223	<	public void testSize(){
223	>	public void testSize() {
224		CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
225	<	CopyOnWriteArraySet full = fullSet(3);
225	>	CopyOnWriteArraySet full = populatedSet(3);
226		assertEquals(3, full.size());
227		assertEquals(0, empty.size());
228		}
229
230		/**
231	<	*  Test to verify 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 = fullSet(3);
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());
#	Line 207 | Line 240 | public class CopyOnWriteArraySetTest ext
240		}
241
242		/**
243	<	*  test to verify 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 = fullSet(3);
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);
#	Line 220 | Line 254 | public class CopyOnWriteArraySetTest ext
254		}
255
256
223	–
224	–	// Exception tests
225	–
257		/**
258	<	*  Test to verify 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 = fullSet(10);
275	>	CopyOnWriteArraySet q = populatedSet(SIZE);
276
277		try {
278		ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
#	Line 253 | Line 287 | public class CopyOnWriteArraySetTest ext
287		assertTrue(q.equals(r));
288		assertTrue(r.equals(q));
289		} catch(Exception e){
290	<	e.printStackTrace();
257	<	fail("unexpected exception");
290	>	unexpectedException();
291		}
292		}
293

Diff Legend

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