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

Diff Legend

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