ViewVC Help

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

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

Comparing jsr166/src/test/tck/CopyOnWriteArrayListTest.java (file contents):
Revision 1.2 by dl, Sun Sep 7 20:39:11 2003 UTC vs.
Revision 1.5 by dl, Thu Sep 25 11:02:41 2003 UTC

#	Line 10 | Line 10 | import java.util.*;
10		import java.util.concurrent.*;
11		import java.io.*;
12
13	<	public class CopyOnWriteArrayListTest extends TestCase{
13	>	public class CopyOnWriteArrayListTest extends JSR166TestCase{
14
15		public static void main(String[] args) {
16		junit.textui.TestRunner.run (suite());
#	Line 20 | Line 20 | public class CopyOnWriteArrayListTest ex
20		return new TestSuite(CopyOnWriteArrayListTest.class);
21		}
22
23	<	static CopyOnWriteArrayList fullArray(int n){
23	>	static CopyOnWriteArrayList populatedArray(int n){
24		CopyOnWriteArrayList a = new CopyOnWriteArrayList();
25		assertTrue(a.isEmpty());
26		for (int i = 0; i < n; ++i)
#	Line 30 | Line 30 | public class CopyOnWriteArrayListTest ex
30		return a;
31		}
32
33	+
34	+	/**
35	+	* a new list is empty
36	+	*/
37	+	public void testConstructor() {
38	+	CopyOnWriteArrayList a = new CopyOnWriteArrayList();
39	+	assertTrue(a.isEmpty());
40	+	}
41	+
42	+	/**
43	+	* new list contains all elements of initializing array
44	+	*/
45	+	public void testConstructor2() {
46	+	Integer[] ints = new Integer[SIZE];
47	+	for (int i = 0; i < SIZE-1; ++i)
48	+	ints[i] = new Integer(i);
49	+	CopyOnWriteArrayList a = new CopyOnWriteArrayList(ints);
50	+	for (int i = 0; i < SIZE; ++i)
51	+	assertEquals(ints[i], a.get(i));
52	+	}
53	+
54	+	/**
55	+	* new list contains all elements of initializing collection
56	+	*/
57	+	public void testConstructor3() {
58	+	Integer[] ints = new Integer[SIZE];
59	+	for (int i = 0; i < SIZE-1; ++i)
60	+	ints[i] = new Integer(i);
61	+	CopyOnWriteArrayList a = new CopyOnWriteArrayList(Arrays.asList(ints));
62	+	for (int i = 0; i < SIZE; ++i)
63	+	assertEquals(ints[i], a.get(i));
64	+	}
65	+
66	+
67		/**
68	<	*  Test to verify addAll correctly adds each element from the given collection
68	>	*   addAll  adds each element from the given collection
69		*/
70	<	public void testAddAll(){
71	<	CopyOnWriteArrayList full = fullArray(3);
70	>	public void testAddAll() {
71	>	CopyOnWriteArrayList full = populatedArray(3);
72		Vector v = new Vector();
73	<	v.add(new Integer(3));
74	<	v.add(new Integer(4));
75	<	v.add(new Integer(5));
73	>	v.add(three);
74	>	v.add(four);
75	>	v.add(five);
76		full.addAll(v);
77		assertEquals(6, full.size());
78		}
79
80		/**
81	<	*  Test to verify addAllAbsent adds each element from the given collection that did not
81	>	*   addAllAbsent adds each element from the given collection that did not
82		*  already exist in the List
83		*/
84	<	public void testAddAllAbsent(){
85	<	CopyOnWriteArrayList full = fullArray(3);
84	>	public void testAddAllAbsent() {
85	>	CopyOnWriteArrayList full = populatedArray(3);
86		Vector v = new Vector();
87	<	v.add(new Integer(3));
88	<	v.add(new Integer(4));
89	<	v.add(new Integer(1)); // will not add this element
87	>	v.add(three);
88	>	v.add(four);
89	>	v.add(one); // will not add this element
90		full.addAllAbsent(v);
91		assertEquals(5, full.size());
92		}
93
94		/**
95	<	*  Test to verify addIfAbsent will not add the element if it already exists in the list
95	>	*   addIfAbsent will not add the element if it already exists in the list
96		*/
97	<	public void testAddIfAbsent(){
98	<	CopyOnWriteArrayList full = fullArray(3);
99	<	full.addIfAbsent(new Integer(1));
100	<	assertEquals(3, full.size());
97	>	public void testAddIfAbsent() {
98	>	CopyOnWriteArrayList full = populatedArray(SIZE);
99	>	full.addIfAbsent(one);
100	>	assertEquals(SIZE, full.size());
101		}
102
103		/**
104	<	*  test to verify addIfAbsent correctly adds the element when it does not exist in the list
104	>	*   addIfAbsent adds the element when it does not exist in the list
105		*/
106	<	public void testAddIfAbsent2(){
107	<	CopyOnWriteArrayList full = fullArray(3);
108	<	full.addIfAbsent(new Integer(3));
109	<	assertTrue(full.contains(new Integer(3)));
106	>	public void testAddIfAbsent2() {
107	>	CopyOnWriteArrayList full = populatedArray(SIZE);
108	>	full.addIfAbsent(three);
109	>	assertTrue(full.contains(three));
110		}
111
112		/**
113	<	*  Test to verify clear correctly removes all elements from the list
113	>	*   clear removes all elements from the list
114		*/
115	<	public void testClear(){
116	<	CopyOnWriteArrayList full = fullArray(3);
115	>	public void testClear() {
116	>	CopyOnWriteArrayList full = populatedArray(SIZE);
117		full.clear();
118		assertEquals(0, full.size());
119		}
120
121	+
122	+	/**
123	+	*  Cloned list is equal
124	+	*/
125	+	public void testClone() {
126	+	CopyOnWriteArrayList l1 = populatedArray(SIZE);
127	+	CopyOnWriteArrayList l2 = (CopyOnWriteArrayList)(l1.clone());
128	+	assertEquals(l1, l2);
129	+	l1.clear();
130	+	assertFalse(l1.equals(l2));
131	+	}
132	+
133		/**
134	<	*  Test to verify contains returns the correct values
134	>	*   contains is true for added elements
135		*/
136	<	public void testContains(){
137	<	CopyOnWriteArrayList full = fullArray(3);
138	<	assertTrue(full.contains(new Integer(1)));
139	<	assertFalse(full.contains(new Integer(5)));
136	>	public void testContains() {
137	>	CopyOnWriteArrayList full = populatedArray(3);
138	>	assertTrue(full.contains(one));
139	>	assertFalse(full.contains(five));
140		}
141
142	+	/**
143	+	* adding at an index places it in the indindicated index
144	+	*/
145		public void testAddIndex() {
146	<	CopyOnWriteArrayList full = fullArray(3);
147	<	full.add(0, new Integer(-1));
146	>	CopyOnWriteArrayList full = populatedArray(3);
147	>	full.add(0, m1);
148		assertEquals(4, full.size());
149	<	assertEquals(new Integer(-1), full.get(0));
150	<	assertEquals(new Integer(0), full.get(1));
149	>	assertEquals(m1, full.get(0));
150	>	assertEquals(zero, full.get(1));
151
152	<	full.add(2, new Integer(-2));
152	>	full.add(2, m2);
153		assertEquals(5, full.size());
154	<	assertEquals(new Integer(-2), full.get(2));
155	<	assertEquals(new Integer(2), full.get(4));
154	>	assertEquals(m2, full.get(2));
155	>	assertEquals(two, full.get(4));
156		}
157
158	+	/**
159	+	* lists with same elements are equal and have same hashCode
160	+	*/
161		public void testEquals() {
162	<	CopyOnWriteArrayList a = fullArray(3);
163	<	CopyOnWriteArrayList b = fullArray(3);
162	>	CopyOnWriteArrayList a = populatedArray(3);
163	>	CopyOnWriteArrayList b = populatedArray(3);
164		assertTrue(a.equals(b));
165		assertTrue(b.equals(a));
166		assertEquals(a.hashCode(), b.hashCode());
167	<	a.add(new Integer(-1));
167	>	a.add(m1);
168		assertFalse(a.equals(b));
169		assertFalse(b.equals(a));
170	<	b.add(new Integer(-1));
170	>	b.add(m1);
171		assertTrue(a.equals(b));
172		assertTrue(b.equals(a));
173		assertEquals(a.hashCode(), b.hashCode());
#	Line 123 | Line 175 | public class CopyOnWriteArrayListTest ex
175
176
177		/**
178	<	*  Test to verify containsAll returns the correct values
178	>	*   containsAll returns true for collection with subset of elements
179		*/
180	<	public void testContainsAll(){
181	<	CopyOnWriteArrayList full = fullArray(3);
180	>	public void testContainsAll() {
181	>	CopyOnWriteArrayList full = populatedArray(3);
182		Vector v = new Vector();
183	<	v.add(new Integer(1));
184	<	v.add(new Integer(2));
183	>	v.add(one);
184	>	v.add(two);
185		assertTrue(full.containsAll(v));
186	<	v.add(new Integer(6));
186	>	v.add(six);
187		assertFalse(full.containsAll(v));
188		}
189
190		/**
191	<	*  Test to verify get returns the correct value for the given index
191	>	*   get returns the  value at the given index
192		*/
193	<	public void testGet(){
194	<	CopyOnWriteArrayList full = fullArray(3);
193	>	public void testGet() {
194	>	CopyOnWriteArrayList full = populatedArray(3);
195		assertEquals(0, ((Integer)full.get(0)).intValue());
196		}
197
198		/**
199	<	*  Test to verify indexOf gives the correct index for the given object
199	>	*   indexOf gives the index for the given object
200		*/
201	<	public void testIndexOf(){
202	<	CopyOnWriteArrayList full = fullArray(3);
203	<	assertEquals(1, full.indexOf(new Integer(1)));
201	>	public void testIndexOf() {
202	>	CopyOnWriteArrayList full = populatedArray(3);
203	>	assertEquals(1, full.indexOf(one));
204		assertEquals(-1, full.indexOf("puppies"));
205		}
206
207		/**
208	<	*  Test to verify indexOf gives the correct index based on the given index
208	>	*   indexOf gives the index based on the given index
209		*  at which to start searching
210		*/
211	<	public void testIndexOf2(){
212	<	CopyOnWriteArrayList full = fullArray(3);
213	<	assertEquals(1, full.indexOf(new Integer(1), 0));
214	<	assertEquals(-1, full.indexOf(new Integer(1), 2));
211	>	public void testIndexOf2() {
212	>	CopyOnWriteArrayList full = populatedArray(3);
213	>	assertEquals(1, full.indexOf(one, 0));
214	>	assertEquals(-1, full.indexOf(one, 2));
215		}
216
217		/**
218	<	*  Test to verify isEmpty returns the correct values
218	>	*   isEmpty returns true when empty, else false
219		*/
220	<	public void testIsEmpty(){
220	>	public void testIsEmpty() {
221		CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
222	<	CopyOnWriteArrayList full = fullArray(3);
222	>	CopyOnWriteArrayList full = populatedArray(SIZE);
223		assertTrue(empty.isEmpty());
224		assertFalse(full.isEmpty());
225		}
226
227		/**
228	<	*  Test to verify iterator() returns an iterator containing the elements of the list
228	>	*   iterator() returns an iterator containing the elements of the list
229		*/
230	<	public void testIterator(){
231	<	CopyOnWriteArrayList full = fullArray(3);
230	>	public void testIterator() {
231	>	CopyOnWriteArrayList full = populatedArray(SIZE);
232		Iterator i = full.iterator();
233		int j;
234		for(j = 0; i.hasNext(); j++)
235		assertEquals(j, ((Integer)i.next()).intValue());
236	<	assertEquals(3, j);
236	>	assertEquals(SIZE, j);
237		}
238
239	+	/**
240	+	* iterator.remove throws UnsupportedOperationException
241	+	*/
242		public void testIteratorRemove () {
243	<	CopyOnWriteArrayList full = fullArray(3);
243	>	CopyOnWriteArrayList full = populatedArray(SIZE);
244		Iterator it = full.iterator();
245		it.next();
246		try {
247		it.remove();
248	<	fail("should throw");
248	>	shouldThrow();
249		}
250		catch (UnsupportedOperationException success) {}
251		}
252
253	<	public void testToString(){
254	<	CopyOnWriteArrayList full = fullArray(3);
253	>	/**
254	>	* toString contains toString of elements
255	>	*/
256	>	public void testToString() {
257	>	CopyOnWriteArrayList full = populatedArray(3);
258		String s = full.toString();
259		for (int i = 0; i < 3; ++i) {
260		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
#	Line 204 | Line 262 | public class CopyOnWriteArrayListTest ex
262		}
263
264		/**
265	<	*  Test to verify lastIndexOf returns the correct index for the given object
265	>	*   lastIndexOf returns the index for the given object
266		*/
267	<	public void testLastIndexOf1(){
268	<	CopyOnWriteArrayList full = fullArray(3);
269	<	full.add(new Integer(1));
270	<	full.add(new Integer(3));
271	<	assertEquals(3, full.lastIndexOf(new Integer(1)));
272	<	assertEquals(-1, full.lastIndexOf(new Integer(6)));
267	>	public void testLastIndexOf1() {
268	>	CopyOnWriteArrayList full = populatedArray(3);
269	>	full.add(one);
270	>	full.add(three);
271	>	assertEquals(3, full.lastIndexOf(one));
272	>	assertEquals(-1, full.lastIndexOf(six));
273		}
274
275		/**
276	<	*  Test to verify lastIndexOf returns the correct index from the given starting point
276	>	*   lastIndexOf returns the index from the given starting point
277		*/
278	<	public void testlastIndexOf2(){
279	<	CopyOnWriteArrayList full = fullArray(3);
280	<	full.add(new Integer(1));
281	<	full.add(new Integer(3));
282	<	assertEquals(3, full.lastIndexOf(new Integer(1), 4));
283	<	assertEquals(-1, full.lastIndexOf(new Integer(3), 3));
278	>	public void testlastIndexOf2() {
279	>	CopyOnWriteArrayList full = populatedArray(3);
280	>	full.add(one);
281	>	full.add(three);
282	>	assertEquals(3, full.lastIndexOf(one, 4));
283	>	assertEquals(-1, full.lastIndexOf(three, 3));
284		}
285
286		/**
287	<	*  Identical to testIterator, except ListInterator has more functionality
287	>	*  listIterator traverses all elements
288		*/
289	<	public void testListIterator1(){
290	<	CopyOnWriteArrayList full = fullArray(3);
289	>	public void testListIterator1() {
290	>	CopyOnWriteArrayList full = populatedArray(SIZE);
291		ListIterator i = full.listIterator();
292		int j;
293		for(j = 0; i.hasNext(); j++)
294		assertEquals(j, ((Integer)i.next()).intValue());
295	<	assertEquals(3, j);
295	>	assertEquals(SIZE, j);
296		}
297
298		/**
299	<	*  Identical to testIterator and testListIterator1, but only returns those elements
242	<	*  after the given index
299	>	*  listIterator only returns those elements after the given index
300		*/
301	<	public void testListIterator2(){
302	<	CopyOnWriteArrayList full = fullArray(3);
301	>	public void testListIterator2() {
302	>	CopyOnWriteArrayList full = populatedArray(3);
303		ListIterator i = full.listIterator(1);
304		int j;
305		for(j = 0; i.hasNext(); j++)
#	Line 251 | Line 308 | public class CopyOnWriteArrayListTest ex
308		}
309
310		/**
311	<	*  Test to verify remove correctly removes and returns the object at the given index
311	>	*   remove  removes and returns the object at the given index
312		*/
313	<	public void testRemove(){
314	<	CopyOnWriteArrayList full = fullArray(3);
315	<	assertEquals(new Integer(2), full.remove(2));
313	>	public void testRemove() {
314	>	CopyOnWriteArrayList full = populatedArray(3);
315	>	assertEquals(two, full.remove(2));
316		assertEquals(2, full.size());
317		}
318
319		/**
320	<	*  Test to verify removeAll correctly removes all elements from the given collection
320	>	*   removeAll  removes all elements from the given collection
321		*/
322	<	public void testRemoveAll(){
323	<	CopyOnWriteArrayList full = fullArray(3);
322	>	public void testRemoveAll() {
323	>	CopyOnWriteArrayList full = populatedArray(3);
324		Vector v = new Vector();
325	<	v.add(new Integer(1));
326	<	v.add(new Integer(2));
325	>	v.add(one);
326	>	v.add(two);
327		full.removeAll(v);
328		assertEquals(1, full.size());
329		}
330
331		/**
332	<	*  Test to verify set correctly changes the element at the given index
332	>	*   set  changes the element at the given index
333		*/
334	<	public void testSet(){
335	<	CopyOnWriteArrayList full = fullArray(3);
336	<	assertEquals(new Integer(2), full.set(2, new Integer(4)));
334	>	public void testSet() {
335	>	CopyOnWriteArrayList full = populatedArray(3);
336	>	assertEquals(two, full.set(2, four));
337		assertEquals(4, ((Integer)full.get(2)).intValue());
338		}
339
340		/**
341	<	*  Test to verify size returns the correct values
341	>	*   size returns the number of elements
342		*/
343	<	public void testSize(){
343	>	public void testSize() {
344		CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
345	<	CopyOnWriteArrayList full = fullArray(3);
346	<	assertEquals(3, full.size());
345	>	CopyOnWriteArrayList full = populatedArray(SIZE);
346	>	assertEquals(SIZE, full.size());
347		assertEquals(0, empty.size());
348		}
349
350		/**
351	<	*  Test to verify toArray returns an Object array containing all elements from the list
351	>	*   toArray returns an Object array containing all elements from the list
352		*/
353	<	public void testToArray(){
354	<	CopyOnWriteArrayList full = fullArray(3);
353	>	public void testToArray() {
354	>	CopyOnWriteArrayList full = populatedArray(3);
355		Object[] o = full.toArray();
356		assertEquals(3, o.length);
357		assertEquals(0, ((Integer)o[0]).intValue());
#	Line 303 | Line 360 | public class CopyOnWriteArrayListTest ex
360		}
361
362		/**
363	<	*  test to verify toArray returns an Integer array containing all elements from the list
363	>	*   toArray returns an Integer array containing all elements from
364	>	*   the list
365		*/
366	<	public void testToArray2(){
367	<	CopyOnWriteArrayList full = fullArray(3);
366	>	public void testToArray2() {
367	>	CopyOnWriteArrayList full = populatedArray(3);
368		Integer[] i = new Integer[3];
369		i = (Integer[])full.toArray(i);
370		assertEquals(3, i.length);
#	Line 316 | Line 374 | public class CopyOnWriteArrayListTest ex
374		}
375
376
377	+	/**
378	+	* sublists contains elements at indexes offset from their base
379	+	*/
380		public void testSubList() {
381	<	CopyOnWriteArrayList a = fullArray(10);
381	>	CopyOnWriteArrayList a = populatedArray(10);
382		assertTrue(a.subList(1,1).isEmpty());
383		for(int j = 0; j < 9; ++j) {
384		for(int i = j ; i < 10; ++i) {
#	Line 328 | Line 389 | public class CopyOnWriteArrayListTest ex
389		}
390		}
391
331	–	Integer m1 = new Integer(-1);
392		List s = a.subList(2, 5);
393		assertEquals(s.size(), 3);
394	<	s.set(2, new Integer(m1));
394	>	s.set(2, m1);
395		assertEquals(a.get(4), m1);
396		s.clear();
397		assertEquals(a.size(), 7);
#	Line 340 | Line 400 | public class CopyOnWriteArrayListTest ex
400		// Exception tests
401
402		/**
403	<	*  Test to verify toArray throws an ArrayStoreException when the given array
403	>	*   toArray throws an ArrayStoreException when the given array
404		*  can not store the objects inside the list
405		*/
406	<	public void testToArray_ArrayStoreException(){
407	<	try{
406	>	public void testToArray_ArrayStoreException() {
407	>	try {
408		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
409		c.add("zfasdfsdf");
410		c.add("asdadasd");
411		c.toArray(new Long[5]);
412	<	fail("Object[] toArray(Object[]) should throw ArrayStoreException");
413	<	}catch(ArrayStoreException e){}
412	>	shouldThrow();
413	>	} catch(ArrayStoreException e){}
414		}
415
416		/**
417	<	*  Test to verify get throws an IndexOutOfBoundsException on a negative index
417	>	*   get throws an IndexOutOfBoundsException on a negative index
418		*/
419	<	public void testGet1_IndexOutOfBoundsException(){
420	<	try{
419	>	public void testGet1_IndexOutOfBoundsException() {
420	>	try {
421		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
422		c.get(-1);
423	<	fail("Object get(int) should throw IndexOutOfBounds exception");
424	<	}catch(IndexOutOfBoundsException e){}
423	>	shouldThrow();
424	>	} catch(IndexOutOfBoundsException e){}
425		}
426
427		/**
428	<	*  Test to verify get throws an IndexOutOfBoundsException on a too high index
428	>	*   get throws an IndexOutOfBoundsException on a too high index
429		*/
430	<	public void testGet2_IndexOutOfBoundsException(){
431	<	try{
430	>	public void testGet2_IndexOutOfBoundsException() {
431	>	try {
432		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
433		c.add("asdasd");
434		c.add("asdad");
435		c.get(100);
436	<	fail("Object get(int) should throw IndexOutOfBounds exception");
437	<	}catch(IndexOutOfBoundsException e){}
436	>	shouldThrow();
437	>	} catch(IndexOutOfBoundsException e){}
438		}
439
440		/**
441	<	*  Test to verify set throws an IndexOutOfBoundsException on a negative index
441	>	*   set throws an IndexOutOfBoundsException on a negative index
442		*/
443	<	public void testSet1_IndexOutOfBoundsException(){
444	<	try{
443	>	public void testSet1_IndexOutOfBoundsException() {
444	>	try {
445		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
446		c.set(-1,"qwerty");
447	<	fail("Object get(int, Object) should throw IndexOutOfBounds exception");
448	<	}catch(IndexOutOfBoundsException e){}
447	>	shouldThrow();
448	>	} catch(IndexOutOfBoundsException e){}
449		}
450
451		/**
452	<	*  Test to verify set throws an IndexOutOfBoundsException on a too high index
452	>	*   set throws an IndexOutOfBoundsException on a too high index
453		*/
454	<	public void testSet2(){
455	<	try{
454	>	public void testSet2() {
455	>	try {
456		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
457		c.add("asdasd");
458		c.add("asdad");
459		c.set(100, "qwerty");
460	<	fail("Object set(int, Object) should throw IndexOutOfBounds exception");
461	<	}catch(IndexOutOfBoundsException e){}
460	>	shouldThrow();
461	>	} catch(IndexOutOfBoundsException e){}
462		}
463
464		/**
465	<	*  Test to verify add throws an IndexOutOfBoundsException on a negative index
465	>	*   add throws an IndexOutOfBoundsException on a negative index
466		*/
467	<	public void testAdd1_IndexOutOfBoundsException(){
468	<	try{
467	>	public void testAdd1_IndexOutOfBoundsException() {
468	>	try {
469		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
470		c.add(-1,"qwerty");
471	<	fail("void add(int, Object) should throw IndexOutOfBounds exception");
472	<	}catch(IndexOutOfBoundsException e){}
471	>	shouldThrow();
472	>	} catch(IndexOutOfBoundsException e){}
473		}
474
475		/**
476	<	*  Test to verify add throws an IndexOutOfBoundsException on a too high index
476	>	*   add throws an IndexOutOfBoundsException on a too high index
477		*/
478	<	public void testAdd2_IndexOutOfBoundsException(){
479	<	try{
478	>	public void testAdd2_IndexOutOfBoundsException() {
479	>	try {
480		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
481		c.add("asdasd");
482		c.add("asdasdasd");
483		c.add(100, "qwerty");
484	<	fail("void add(int, Object) should throw IndexOutOfBounds exception");
485	<	}catch(IndexOutOfBoundsException e){}
484	>	shouldThrow();
485	>	} catch(IndexOutOfBoundsException e){}
486		}
487
488		/**
489	<	*  Test to verify remove throws an IndexOutOfBoundsException on a negative index
489	>	*   remove throws an IndexOutOfBoundsException on a negative index
490		*/
491	<	public void testRemove1_IndexOutOfBounds(){
492	<	try{
491	>	public void testRemove1_IndexOutOfBounds() {
492	>	try {
493		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
494		c.remove(-1);
495	<	fail("Object remove(int) should throw IndexOutOfBounds exception");
496	<	}catch(IndexOutOfBoundsException e){}
495	>	shouldThrow();
496	>	} catch(IndexOutOfBoundsException e){}
497		}
498
499		/**
500	<	*  Test to verify remove throws an IndexOutOfBoundsException on a too high index
500	>	*   remove throws an IndexOutOfBoundsException on a too high index
501		*/
502	<	public void testRemove2_IndexOutOfBounds(){
503	<	try{
502	>	public void testRemove2_IndexOutOfBounds() {
503	>	try {
504		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
505		c.add("asdasd");
506		c.add("adasdasd");
507		c.remove(100);
508	<	fail("Object remove(int) should throw IndexOutOfBounds exception");
509	<	}catch(IndexOutOfBoundsException e){}
508	>	shouldThrow();
509	>	} catch(IndexOutOfBoundsException e){}
510		}
511
512		/**
513	<	*  Test to verify addAll throws an IndexOutOfBoundsException on a negative index
513	>	*   addAll throws an IndexOutOfBoundsException on a negative index
514		*/
515	<	public void testAddAll1_IndexOutOfBoundsException(){
516	<	try{
515	>	public void testAddAll1_IndexOutOfBoundsException() {
516	>	try {
517		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
518		c.addAll(-1,new LinkedList());
519	<	fail("boolean add(int, Collection) should throw IndexOutOfBounds exception");
520	<	}catch(IndexOutOfBoundsException e){}
519	>	shouldThrow();
520	>	} catch(IndexOutOfBoundsException e){}
521		}
522
523		/**
524	<	*  Test to verify addAll throws an IndexOutOfBoundsException on a too high index
524	>	*   addAll throws an IndexOutOfBoundsException on a too high index
525		*/
526	<	public void testAddAll2_IndexOutOfBoundsException(){
527	<	try{
526	>	public void testAddAll2_IndexOutOfBoundsException() {
527	>	try {
528		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
529		c.add("asdasd");
530		c.add("asdasdasd");
531		c.addAll(100, new LinkedList());
532	<	fail("boolean addAll(int, Collection) should throw IndexOutOfBounds exception");
533	<	}catch(IndexOutOfBoundsException e){}
532	>	shouldThrow();
533	>	} catch(IndexOutOfBoundsException e){}
534		}
535
536		/**
537	<	*  Test to verify listIterator throws an IndexOutOfBoundsException on a negative index
537	>	*   listIterator throws an IndexOutOfBoundsException on a negative index
538		*/
539	<	public void testListIterator1_IndexOutOfBoundsException(){
540	<	try{
539	>	public void testListIterator1_IndexOutOfBoundsException() {
540	>	try {
541		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
542		c.listIterator(-1);
543	<	fail("ListIterator listIterator(int) should throw IndexOutOfBounds exceptione");
544	<	}catch(IndexOutOfBoundsException e){}
543	>	shouldThrow();
544	>	} catch(IndexOutOfBoundsException e){}
545		}
546
547		/**
548	<	*  Test to verify listIterator throws an IndexOutOfBoundsException on a too high index
548	>	*   listIterator throws an IndexOutOfBoundsException on a too high index
549		*/
550	<	public void testListIterator2_IndexOutOfBoundsException(){
551	<	try{
550	>	public void testListIterator2_IndexOutOfBoundsException() {
551	>	try {
552		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
553		c.add("adasd");
554		c.add("asdasdas");
555		c.listIterator(100);
556	<	fail("ListIterator listIterator(int) should throw IndexOutOfBounds exception");
557	<	}catch(IndexOutOfBoundsException e){}
556	>	shouldThrow();
557	>	} catch(IndexOutOfBoundsException e){}
558		}
559
560		/**
561	<	*  Test to verify subList throws an IndexOutOfBoundsException on a negative index
561	>	*   subList throws an IndexOutOfBoundsException on a negative index
562		*/
563	<	public void testSubList1_IndexOutOfBoundsException(){
564	<	try{
563	>	public void testSubList1_IndexOutOfBoundsException() {
564	>	try {
565		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
566		c.subList(-1,100);
567
568	<	fail("List subList(int, int) should throw IndexOutofBounds exception");
569	<	}catch(IndexOutOfBoundsException e){}
568	>	shouldThrow();
569	>	} catch(IndexOutOfBoundsException e){}
570		}
571
572		/**
573	<	*  Test to verify subList throws an IndexOutOfBoundsException on a too high index
573	>	*   subList throws an IndexOutOfBoundsException on a too high index
574		*/
575	<	public void testSubList2_IndexOutOfBoundsException(){
576	<	try{
575	>	public void testSubList2_IndexOutOfBoundsException() {
576	>	try {
577		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
578		c.add("asdasd");
579		c.subList(1,100);
580	<	fail("List subList(int, int) should throw IndexOutofBounds exception");
581	<	}catch(IndexOutOfBoundsException e){}
580	>	shouldThrow();
581	>	} catch(IndexOutOfBoundsException e){}
582		}
583
584		/**
585	<	*  Test to verify subList throws IndexOutOfBoundsException when the second index
585	>	*   subList throws IndexOutOfBoundsException when the second index
586		*  is lower then the first
587		*/
588	<	public void testSubList3_IndexOutOfBoundsException(){
589	<	try{
588	>	public void testSubList3_IndexOutOfBoundsException() {
589	>	try {
590		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
591		c.subList(3,1);
592
593	<	fail("List subList(int, int) should throw IndexOutofBounds exception");
594	<	}catch(IndexOutOfBoundsException e){}
593	>	shouldThrow();
594	>	} catch(IndexOutOfBoundsException e){}
595		}
596
597	+	/**
598	+	* a deserialized serialiszed list is equal
599	+	*/
600		public void testSerialization() {
601	<	CopyOnWriteArrayList q = fullArray(10);
601	>	CopyOnWriteArrayList q = populatedArray(SIZE);
602
603		try {
604		ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
#	Line 550 | Line 613 | public class CopyOnWriteArrayListTest ex
613		assertTrue(q.equals(r));
614		assertTrue(r.equals(q));
615		} catch(Exception e){
616	<	e.printStackTrace();
554	<	fail("unexpected exception");
616	>	unexpectedException();
617		}
618		}
619

Diff Legend

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