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.15 by jsr166, Tue Dec 1 09:56:28 2009 UTC vs.
Revision 1.26 by jsr166, Tue Nov 29 05:23:56 2011 UTC

#	Line 1 | Line 1
1		/*
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
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
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);
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
#	Line 64 | Line 79 | public class CopyOnWriteArrayListTest ex
79		assertEquals(ints[i], a.get(i));
80		}
81
67	–
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);
#	Line 79 | Line 93 | public class CopyOnWriteArrayListTest ex
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);
#	Line 93 | Line 107 | public class CopyOnWriteArrayListTest ex
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);
#	Line 102 | Line 116 | public class CopyOnWriteArrayListTest ex
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);
#	Line 111 | Line 125 | public class CopyOnWriteArrayListTest ex
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);
#	Line 119 | Line 133 | public class CopyOnWriteArrayListTest ex
133		assertEquals(0, full.size());
134		}
135
122	–
136		/**
137	<	*  Cloned list is equal
137	>	* Cloned list is equal
138		*/
139		public void testClone() {
140		CopyOnWriteArrayList l1 = populatedArray(SIZE);
#	Line 132 | Line 145 | public class CopyOnWriteArrayListTest ex
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);
#	Line 174 | Line 187 | public class CopyOnWriteArrayListTest ex
187		assertEquals(a.hashCode(), b.hashCode());
188		}
189
177	–
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);
#	Line 189 | Line 201 | public class CopyOnWriteArrayListTest ex
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);
#	Line 197 | Line 209 | public class CopyOnWriteArrayListTest ex
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);
#	Line 206 | Line 218 | public class CopyOnWriteArrayListTest ex
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);
#	Line 216 | Line 228 | public class CopyOnWriteArrayListTest ex
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();
#	Line 226 | Line 238 | public class CopyOnWriteArrayListTest ex
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);
#	Line 240 | Line 252 | public class CopyOnWriteArrayListTest ex
252		/**
253		* iterator.remove throws UnsupportedOperationException
254		*/
255	<	public void testIteratorRemove () {
255	>	public void testIteratorRemove() {
256		CopyOnWriteArrayList full = populatedArray(SIZE);
257		Iterator it = full.iterator();
258		it.next();
#	Line 257 | Line 269 | public class CopyOnWriteArrayListTest ex
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		}
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);
#	Line 273 | Line 285 | public class CopyOnWriteArrayListTest ex
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() {
290	>	public void testLastIndexOf2() {
291		CopyOnWriteArrayList full = populatedArray(3);
292		full.add(one);
293		full.add(three);
#	Line 284 | Line 296 | public class CopyOnWriteArrayListTest ex
296		}
297
298		/**
299	<	*  listIterator traverses all elements
299	>	* listIterator traverses all elements
300		*/
301		public void testListIterator1() {
302		CopyOnWriteArrayList full = populatedArray(SIZE);
#	Line 296 | Line 308 | public class CopyOnWriteArrayListTest ex
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);
#	Line 308 | Line 320 | public class CopyOnWriteArrayListTest ex
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);
#	Line 317 | Line 329 | public class CopyOnWriteArrayListTest ex
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);
#	Line 329 | Line 341 | public class CopyOnWriteArrayListTest ex
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);
#	Line 338 | Line 350 | public class CopyOnWriteArrayListTest ex
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();
#	Line 348 | Line 360 | public class CopyOnWriteArrayListTest ex
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, o[0]);
371	<	assertEquals(1, o[1]);
372	<	assertEquals(2, o[2]);
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
#	Line 390 | Line 438 | public class CopyOnWriteArrayListTest ex
438		}
439
440		List s = a.subList(2, 5);
441	<	assertEquals(s.size(), 3);
441	>	assertEquals(3, s.size());
442		s.set(2, m1);
443		assertEquals(a.get(4), m1);
444		s.clear();
445	<	assertEquals(a.size(), 7);
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 414 | Line 462 | public class CopyOnWriteArrayListTest ex
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 {
#	Line 425 | Line 473 | public class CopyOnWriteArrayListTest ex
473		}
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 438 | Line 486 | public class CopyOnWriteArrayListTest ex
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 {
#	Line 449 | Line 497 | public class CopyOnWriteArrayListTest ex
497		}
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 462 | Line 510 | public class CopyOnWriteArrayListTest ex
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 {
#	Line 473 | Line 521 | public class CopyOnWriteArrayListTest ex
521		}
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 486 | Line 534 | public class CopyOnWriteArrayListTest ex
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 {
#	Line 497 | Line 545 | public class CopyOnWriteArrayListTest ex
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 510 | Line 558 | public class CopyOnWriteArrayListTest ex
558		}
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 {
#	Line 521 | Line 569 | public class CopyOnWriteArrayListTest ex
569		}
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 534 | Line 582 | public class CopyOnWriteArrayListTest ex
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 {
#	Line 545 | Line 593 | public class CopyOnWriteArrayListTest ex
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 558 | Line 606 | public class CopyOnWriteArrayListTest ex
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 {
#	Line 569 | Line 617 | public class CopyOnWriteArrayListTest ex
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 581 | Line 629 | public class CopyOnWriteArrayListTest ex
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 {
#	Line 593 | Line 641 | public class CopyOnWriteArrayListTest ex
641		}
642
643		/**
644	<	* a deserialized serialiszed list is equal
644	>	* a deserialized serialized list is equal
645		*/
646		public void testSerialization() throws Exception {
647	<	CopyOnWriteArrayList q = populatedArray(SIZE);
647	>	List x = populatedArray(SIZE);
648	>	List y = serialClone(x);
649
650	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
651	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
652	<	out.writeObject(q);
653	<	out.close();
654	<
655	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
656	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
657	<	CopyOnWriteArrayList r = (CopyOnWriteArrayList)in.readObject();
658	<	assertEquals(q.size(), r.size());
659	<	assertTrue(q.equals(r));
660	<	assertTrue(r.equals(q));
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
663		}

Diff Legend

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