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.10 by jsr166, Mon Nov 16 05:30:07 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);
20		}
21
22	<	static CopyOnWriteArraySet populatedSet(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)
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();
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)
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(){
56	>	public void testAddAll() {
57		CopyOnWriteArraySet full = populatedSet(3);
58		Vector v = new Vector();
59		v.add(three);
#	Line 59 | Line 64 | public class CopyOnWriteArraySetTest ext
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(){
70	>	public void testAddAll2() {
71		CopyOnWriteArraySet full = populatedSet(3);
72		Vector v = new Vector();
73		v.add(three);
#	Line 73 | Line 78 | public class CopyOnWriteArraySetTest ext
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(){
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(){
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(){
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(){
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);
#	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(){
139	>	public void testContainsAll() {
140		CopyOnWriteArraySet full = populatedSet(3);
141		Vector v = new Vector();
142		v.add(one);
#	Line 138 | Line 147 | public class CopyOnWriteArraySetTest ext
147		}
148
149		/**
150	<	*   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 = populatedSet(3);
155		assertTrue(empty.isEmpty());
#	Line 148 | Line 157 | public class CopyOnWriteArraySetTest ext
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(){
162	>	public void testIterator() {
163		CopyOnWriteArraySet full = populatedSet(3);
164		Iterator i = full.iterator();
165		int j;
166	<	for(j = 0; i.hasNext(); 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);
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(){
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(){
200	>	public void testRemoveAll() {
201		CopyOnWriteArraySet full = populatedSet(3);
202		Vector v = new Vector();
203		v.add(one);
#	Line 192 | Line 207 | public class CopyOnWriteArraySetTest ext
207		}
208
209
210	<	public void testRemove(){
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));
#	Line 200 | Line 218 | public class CopyOnWriteArraySetTest ext
218		}
219
220		/**
221	<	*   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 = populatedSet(3);
226		assertEquals(3, full.size());
#	Line 210 | Line 228 | public class CopyOnWriteArraySetTest ext
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(){
233	>	public void testToArray() {
234		CopyOnWriteArraySet full = populatedSet(3);
235		Object[] o = full.toArray();
236		assertEquals(3, o.length);
#	Line 222 | Line 240 | public class CopyOnWriteArraySetTest ext
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(){
246	>	public void testToArray2() {
247		CopyOnWriteArraySet full = populatedSet(3);
248		Integer[] i = new Integer[3];
249		i = (Integer[])full.toArray(i);
#	Line 235 | Line 254 | public class CopyOnWriteArraySetTest ext
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