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.4 by dl, Sat Sep 20 18:20:07 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 10 | Line 11 | import java.util.*;
11		import java.util.concurrent.*;
12		import java.io.*;
13
14	<	public class CopyOnWriteArrayListTest extends JSR166TestCase{
15	<
14	>	public class CopyOnWriteArrayListTest extends JSR166TestCase {
15	>
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run (suite());
18		}
19
20		public static Test suite() {
21		return new TestSuite(CopyOnWriteArrayListTest.class);
22		}
23
24	<	static CopyOnWriteArrayList populatedArray(int n){
24	>	static CopyOnWriteArrayList populatedArray(int n) {
25		CopyOnWriteArrayList a = new CopyOnWriteArrayList();
26		assertTrue(a.isEmpty());
27	<	for (int i = 0; i < n; ++i)
27	>	for (int i = 0; i < n; ++i)
28		a.add(new Integer(i));
29		assertFalse(a.isEmpty());
30		assertEquals(n, a.size());
#	Line 32 | Line 33 | public class CopyOnWriteArrayListTest ex
33
34
35		/**
36	<	*
36	>	* a new list is empty
37		*/
38		public void testConstructor() {
39		CopyOnWriteArrayList a = new CopyOnWriteArrayList();
#	Line 40 | Line 41 | public class CopyOnWriteArrayListTest ex
41		}
42
43		/**
44	<	*
44	>	* new list contains all elements of initializing array
45		*/
46		public void testConstructor2() {
47		Integer[] ints = new Integer[SIZE];
48		for (int i = 0; i < SIZE-1; ++i)
49		ints[i] = new Integer(i);
50		CopyOnWriteArrayList a = new CopyOnWriteArrayList(ints);
51	<	for (int i = 0; i < SIZE; ++i)
51	>	for (int i = 0; i < SIZE; ++i)
52		assertEquals(ints[i], a.get(i));
53		}
54
55		/**
56	<	*
56	>	* new list contains all elements of initializing collection
57		*/
58		public void testConstructor3() {
59		Integer[] ints = new Integer[SIZE];
60		for (int i = 0; i < SIZE-1; ++i)
61		ints[i] = new Integer(i);
62		CopyOnWriteArrayList a = new CopyOnWriteArrayList(Arrays.asList(ints));
63	<	for (int i = 0; i < SIZE; ++i)
63	>	for (int i = 0; i < SIZE; ++i)
64		assertEquals(ints[i], a.get(i));
65		}
66	<
66	>
67
68		/**
69	<	*   addAll correctly adds each element from the given collection
69	>	*   addAll  adds each element from the given collection
70		*/
71		public void testAddAll() {
72		CopyOnWriteArrayList full = populatedArray(3);
#	Line 101 | Line 102 | public class CopyOnWriteArrayListTest ex
102		}
103
104		/**
105	<	*   addIfAbsent correctly adds the element when it does not exist in the list
105	>	*   addIfAbsent adds the element when it does not exist in the list
106		*/
107		public void testAddIfAbsent2() {
108		CopyOnWriteArrayList full = populatedArray(SIZE);
#	Line 110 | Line 111 | public class CopyOnWriteArrayListTest ex
111		}
112
113		/**
114	<	*   clear correctly removes all elements from the list
114	>	*   clear removes all elements from the list
115		*/
116		public void testClear() {
117		CopyOnWriteArrayList full = populatedArray(SIZE);
#	Line 131 | Line 132 | public class CopyOnWriteArrayListTest ex
132		}
133
134		/**
135	<	*   contains returns the correct values
135	>	*   contains is true for added elements
136		*/
137		public void testContains() {
138		CopyOnWriteArrayList full = populatedArray(3);
#	Line 140 | Line 141 | public class CopyOnWriteArrayListTest ex
141		}
142
143		/**
144	<	*
144	>	* adding at an index places it in the indicated index
145		*/
146		public void testAddIndex() {
147		CopyOnWriteArrayList full = populatedArray(3);
#	Line 156 | Line 157 | public class CopyOnWriteArrayListTest ex
157		}
158
159		/**
160	<	*
160	>	* lists with same elements are equal and have same hashCode
161		*/
162		public void testEquals() {
163		CopyOnWriteArrayList a = populatedArray(3);
#	Line 173 | Line 174 | public class CopyOnWriteArrayListTest ex
174		assertEquals(a.hashCode(), b.hashCode());
175		}
176
177	<
177	>
178		/**
179	<	*   containsAll returns the correct values
179	>	*   containsAll returns true for collection with subset of elements
180		*/
181		public void testContainsAll() {
182		CopyOnWriteArrayList full = populatedArray(3);
#	Line 188 | Line 189 | public class CopyOnWriteArrayListTest ex
189		}
190
191		/**
192	<	*   get returns the correct value for the given index
192	>	*   get returns the  value at the given index
193		*/
194		public void testGet() {
195		CopyOnWriteArrayList full = populatedArray(3);
#	Line 196 | Line 197 | public class CopyOnWriteArrayListTest ex
197		}
198
199		/**
200	<	*   indexOf gives the correct index for the given object
200	>	*   indexOf gives the index for the given object
201		*/
202		public void testIndexOf() {
203		CopyOnWriteArrayList full = populatedArray(3);
#	Line 205 | Line 206 | public class CopyOnWriteArrayListTest ex
206		}
207
208		/**
209	<	*   indexOf gives the correct index based on the given index
209	>	*   indexOf gives the index based on the given index
210		*  at which to start searching
211		*/
212		public void testIndexOf2() {
#	Line 215 | Line 216 | public class CopyOnWriteArrayListTest ex
216		}
217
218		/**
219	<	*   isEmpty returns the correct values
219	>	*   isEmpty returns true when empty, else false
220		*/
221		public void testIsEmpty() {
222		CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
#	Line 225 | Line 226 | public class CopyOnWriteArrayListTest ex
226		}
227
228		/**
229	<	*   iterator() returns an iterator containing the elements of the list
229	>	*   iterator() returns an iterator containing the elements of the list
230		*/
231		public void testIterator() {
232		CopyOnWriteArrayList full = populatedArray(SIZE);
233		Iterator i = full.iterator();
234		int j;
235	<	for(j = 0; i.hasNext(); j++)
235	>	for (j = 0; i.hasNext(); j++)
236		assertEquals(j, ((Integer)i.next()).intValue());
237		assertEquals(SIZE, j);
238		}
239
240		/**
241	<	*
241	>	* iterator.remove throws UnsupportedOperationException
242		*/
243		public void testIteratorRemove () {
244		CopyOnWriteArrayList full = populatedArray(SIZE);
#	Line 251 | Line 252 | public class CopyOnWriteArrayListTest ex
252		}
253
254		/**
255	<	*
255	>	* toString contains toString of elements
256		*/
257		public void testToString() {
258		CopyOnWriteArrayList full = populatedArray(3);
#	Line 259 | Line 260 | public class CopyOnWriteArrayListTest ex
260		for (int i = 0; i < 3; ++i) {
261		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
262		}
263	<	}
263	>	}
264
265		/**
266	<	*   lastIndexOf returns the correct index for the given object
266	>	*   lastIndexOf returns the index for the given object
267		*/
268		public void testLastIndexOf1() {
269		CopyOnWriteArrayList full = populatedArray(3);
#	Line 273 | Line 274 | public class CopyOnWriteArrayListTest ex
274		}
275
276		/**
277	<	*   lastIndexOf returns the correct index from the given starting point
277	>	*   lastIndexOf returns the index from the given starting point
278		*/
279		public void testlastIndexOf2() {
280		CopyOnWriteArrayList full = populatedArray(3);
#	Line 284 | Line 285 | public class CopyOnWriteArrayListTest ex
285		}
286
287		/**
288	<	*  Identical to testIterator, except ListInterator has more functionality
288	>	*  listIterator traverses all elements
289		*/
290		public void testListIterator1() {
291		CopyOnWriteArrayList full = populatedArray(SIZE);
292		ListIterator i = full.listIterator();
293		int j;
294	<	for(j = 0; i.hasNext(); j++)
294	>	for (j = 0; i.hasNext(); j++)
295		assertEquals(j, ((Integer)i.next()).intValue());
296		assertEquals(SIZE, j);
297		}
#	Line 302 | Line 303 | public class CopyOnWriteArrayListTest ex
303		CopyOnWriteArrayList full = populatedArray(3);
304		ListIterator i = full.listIterator(1);
305		int j;
306	<	for(j = 0; i.hasNext(); j++)
306	>	for (j = 0; i.hasNext(); j++)
307		assertEquals(j+1, ((Integer)i.next()).intValue());
308		assertEquals(2, j);
309		}
310
311		/**
312	<	*   remove correctly removes and returns the object at the given index
312	>	*   remove  removes and returns the object at the given index
313		*/
314		public void testRemove() {
315		CopyOnWriteArrayList full = populatedArray(3);
#	Line 317 | Line 318 | public class CopyOnWriteArrayListTest ex
318		}
319
320		/**
321	<	*   removeAll correctly removes all elements from the given collection
321	>	*   removeAll  removes all elements from the given collection
322		*/
323		public void testRemoveAll() {
324		CopyOnWriteArrayList full = populatedArray(3);
#	Line 329 | Line 330 | public class CopyOnWriteArrayListTest ex
330		}
331
332		/**
333	<	*   set correctly changes the element at the given index
333	>	*   set  changes the element at the given index
334		*/
335		public void testSet() {
336		CopyOnWriteArrayList full = populatedArray(3);
#	Line 338 | Line 339 | public class CopyOnWriteArrayListTest ex
339		}
340
341		/**
342	<	*   size returns the correct values
342	>	*   size returns the number of elements
343		*/
344		public void testSize() {
345		CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
#	Line 375 | Line 376 | public class CopyOnWriteArrayListTest ex
376
377
378		/**
379	<	*
379	>	* sublists contains elements at indexes offset from their base
380		*/
381		public void testSubList() {
382		CopyOnWriteArrayList a = populatedArray(10);
383		assertTrue(a.subList(1,1).isEmpty());
384	<	for(int j = 0; j < 9; ++j) {
385	<	for(int i = j ; i < 10; ++i) {
384	>	for (int j = 0; j < 9; ++j) {
385	>	for (int i = j ; i < 10; ++i) {
386		List b = a.subList(j,i);
387	<	for(int k = j; k < i; ++k) {
387	>	for (int k = j; k < i; ++k) {
388		assertEquals(new Integer(k), b.get(k-j));
389		}
390		}
#	Line 410 | Line 411 | public class CopyOnWriteArrayListTest ex
411		c.add("asdadasd");
412		c.toArray(new Long[5]);
413		shouldThrow();
414	<	} catch(ArrayStoreException e){}
414	>	} catch (ArrayStoreException e) {}
415		}
416
417		/**
#	Line 421 | Line 422 | public class CopyOnWriteArrayListTest ex
422		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
423		c.get(-1);
424		shouldThrow();
425	<	} catch(IndexOutOfBoundsException e){}
425	>	} catch (IndexOutOfBoundsException e) {}
426		}
427	<
427	>
428		/**
429		*   get throws an IndexOutOfBoundsException on a too high index
430		*/
#	Line 434 | Line 435 | public class CopyOnWriteArrayListTest ex
435		c.add("asdad");
436		c.get(100);
437		shouldThrow();
438	<	} catch(IndexOutOfBoundsException e){}
438	>	} catch (IndexOutOfBoundsException e) {}
439		}
440
441		/**
#	Line 445 | Line 446 | public class CopyOnWriteArrayListTest ex
446		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
447		c.set(-1,"qwerty");
448		shouldThrow();
449	<	} catch(IndexOutOfBoundsException e){}
449	>	} catch (IndexOutOfBoundsException e) {}
450		}
451	<
451	>
452		/**
453		*   set throws an IndexOutOfBoundsException on a too high index
454		*/
#	Line 458 | Line 459 | public class CopyOnWriteArrayListTest ex
459		c.add("asdad");
460		c.set(100, "qwerty");
461		shouldThrow();
462	<	} catch(IndexOutOfBoundsException e){}
462	>	} catch (IndexOutOfBoundsException e) {}
463		}
464
465		/**
#	Line 469 | Line 470 | public class CopyOnWriteArrayListTest ex
470		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
471		c.add(-1,"qwerty");
472		shouldThrow();
473	<	} catch(IndexOutOfBoundsException e){}
473	>	} catch (IndexOutOfBoundsException e) {}
474		}
475	<
475	>
476		/**
477		*   add throws an IndexOutOfBoundsException on a too high index
478		*/
#	Line 482 | Line 483 | public class CopyOnWriteArrayListTest ex
483		c.add("asdasdasd");
484		c.add(100, "qwerty");
485		shouldThrow();
486	<	} catch(IndexOutOfBoundsException e){}
486	>	} catch (IndexOutOfBoundsException e) {}
487		}
488
489		/**
#	Line 493 | Line 494 | public class CopyOnWriteArrayListTest ex
494		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
495		c.remove(-1);
496		shouldThrow();
497	<	} catch(IndexOutOfBoundsException e){}
497	>	} catch (IndexOutOfBoundsException e) {}
498		}
499
500		/**
#	Line 506 | Line 507 | public class CopyOnWriteArrayListTest ex
507		c.add("adasdasd");
508		c.remove(100);
509		shouldThrow();
510	<	} catch(IndexOutOfBoundsException e){}
510	>	} catch (IndexOutOfBoundsException e) {}
511		}
512	<
512	>
513		/**
514		*   addAll throws an IndexOutOfBoundsException on a negative index
515		*/
#	Line 517 | Line 518 | public class CopyOnWriteArrayListTest ex
518		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
519		c.addAll(-1,new LinkedList());
520		shouldThrow();
521	<	} catch(IndexOutOfBoundsException e){}
521	>	} catch (IndexOutOfBoundsException e) {}
522		}
523	<
523	>
524		/**
525		*   addAll throws an IndexOutOfBoundsException on a too high index
526		*/
#	Line 530 | Line 531 | public class CopyOnWriteArrayListTest ex
531		c.add("asdasdasd");
532		c.addAll(100, new LinkedList());
533		shouldThrow();
534	<	} catch(IndexOutOfBoundsException e){}
534	>	} catch (IndexOutOfBoundsException e) {}
535		}
536
537		/**
#	Line 541 | Line 542 | public class CopyOnWriteArrayListTest ex
542		CopyOnWriteArrayList c = new CopyOnWriteArrayList();
543		c.listIterator(-1);
544		shouldThrow();
545	<	} catch(IndexOutOfBoundsException e){}
545	>	} catch (IndexOutOfBoundsException e) {}
546		}
547
548		/**
#	Line 554 | Line 555 | public class CopyOnWriteArrayListTest ex
555		c.add("asdasdas");
556		c.listIterator(100);
557		shouldThrow();
558	<	} catch(IndexOutOfBoundsException e){}
558	>	} catch (IndexOutOfBoundsException e) {}
559		}
560
561		/**
#	Line 566 | Line 567 | public class CopyOnWriteArrayListTest ex
567		c.subList(-1,100);
568
569		shouldThrow();
570	<	} catch(IndexOutOfBoundsException e){}
570	>	} catch (IndexOutOfBoundsException e) {}
571		}
572
573		/**
#	Line 578 | Line 579 | public class CopyOnWriteArrayListTest ex
579		c.add("asdasd");
580		c.subList(1,100);
581		shouldThrow();
582	<	} catch(IndexOutOfBoundsException e){}
582	>	} catch (IndexOutOfBoundsException e) {}
583		}
584
585		/**
586		*   subList throws IndexOutOfBoundsException when the second index
587	<	*  is lower then the first
587	>	*  is lower then the first
588		*/
589		public void testSubList3_IndexOutOfBoundsException() {
590		try {
#	Line 591 | Line 592 | public class CopyOnWriteArrayListTest ex
592		c.subList(3,1);
593
594		shouldThrow();
595	<	} catch(IndexOutOfBoundsException e){}
595	>	} catch (IndexOutOfBoundsException e) {}
596		}
597
598		/**
599	<	*
599	>	* a deserialized serialiszed list is equal
600		*/
601		public void testSerialization() {
602		CopyOnWriteArrayList q = populatedArray(SIZE);
#	Line 612 | Line 613 | public class CopyOnWriteArrayListTest ex
613		assertEquals(q.size(), r.size());
614		assertTrue(q.equals(r));
615		assertTrue(r.equals(q));
616	<	} catch(Exception e){
616	>	} catch (Exception e) {
617		unexpectedException();
618		}
619		}
620	<
620	>
621		}

Diff Legend

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