ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedListTest.java (file contents):
Revision 1.3 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.44 by jsr166, Wed Jan 4 06:09:58 2017 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.*;
9	>	import java.util.Arrays;
10	>	import java.util.Collection;
11	>	import java.util.Iterator;
12	>	import java.util.LinkedList;
13	>	import java.util.NoSuchElementException;
14	>
15	>	import junit.framework.Test;
16	>	import junit.framework.TestSuite;
17
18		public class LinkedListTest extends JSR166TestCase {
19		public static void main(String[] args) {
20	<	junit.textui.TestRunner.run (suite());
20	>	main(suite(), args);
21		}
22
23		public static Test suite() {
24	<	return new TestSuite(LinkedListTest.class);
24	>	class Implementation implements CollectionImplementation {
25	>	public Class<?> klazz() { return LinkedList.class; }
26	>	public Collection emptyCollection() { return new LinkedList(); }
27	>	public Object makeElement(int i) { return i; }
28	>	public boolean isConcurrent() { return false; }
29	>	public boolean permitsNulls() { return true; }
30	>	}
31	>	class SubListImplementation extends Implementation {
32	>	public Collection emptyCollection() {
33	>	return new LinkedList().subList(0, 0);
34	>	}
35	>	}
36	>	return newTestSuite(
37	>	LinkedListTest.class,
38	>	CollectionTest.testSuite(new Implementation()),
39	>	CollectionTest.testSuite(new SubListImplementation()));
40		}
41
42		/**
43	<	* Create a queue of given size containing consecutive
44	<	* Integers 0 ... n.
43	>	* Returns a new queue of given size containing consecutive
44	>	* Integers 0 ... n - 1.
45		*/
46	<	private LinkedList populatedQueue(int n) {
47	<	LinkedList q = new LinkedList();
46	>	private LinkedList<Integer> populatedQueue(int n) {
47	>	LinkedList<Integer> q = new LinkedList<>();
48		assertTrue(q.isEmpty());
49	<	for(int i = 0; i < n; ++i)
50	<	assertTrue(q.offer(new Integer(i)));
49	>	for (int i = 0; i < n; ++i)
50	>	assertTrue(q.offer(new Integer(i)));
51		assertFalse(q.isEmpty());
52	<	assertEquals(n, q.size());
52	>	assertEquals(n, q.size());
53	>	assertEquals((Integer) 0, q.peekFirst());
54	>	assertEquals((Integer) (n - 1), q.peekLast());
55		return q;
56		}
57	<
58	<	public void testConstructor1(){
57	>
58	>	/**
59	>	* new queue is empty
60	>	*/
61	>	public void testConstructor1() {
62		assertEquals(0, new LinkedList().size());
63		}
64
65	+	/**
66	+	* Initializing from null Collection throws NPE
67	+	*/
68		public void testConstructor3() {
69		try {
70	<	LinkedList q = new LinkedList((Collection)null);
71	<	fail("Cannot make from null collection");
72	<	}
44	<	catch (NullPointerException success) {}
70	>	new LinkedList((Collection)null);
71	>	shouldThrow();
72	>	} catch (NullPointerException success) {}
73		}
74
75	<	public void testConstructor6(){
76	<	try {
77	<	Integer[] ints = new Integer[SIZE];
78	<	for (int i = 0; i < SIZE; ++i)
79	<	ints[i] = new Integer(i);
80	<	LinkedList q = new LinkedList(Arrays.asList(ints));
81	<	for (int i = 0; i < SIZE; ++i)
82	<	assertEquals(ints[i], q.poll());
83	<	}
84	<	finally {}
75	>	/**
76	>	* Queue contains all elements of collection used to initialize
77	>	*/
78	>	public void testConstructor6() {
79	>	Integer[] ints = new Integer[SIZE];
80	>	for (int i = 0; i < SIZE; ++i)
81	>	ints[i] = i;
82	>	LinkedList q = new LinkedList(Arrays.asList(ints));
83	>	for (int i = 0; i < SIZE; ++i)
84	>	assertEquals(ints[i], q.poll());
85		}
86
87	+	/**
88	+	* isEmpty is true before add, false after
89	+	*/
90		public void testEmpty() {
91		LinkedList q = new LinkedList();
92		assertTrue(q.isEmpty());
#	Line 67 | Line 98 | public class LinkedListTest extends JSR1
98		assertTrue(q.isEmpty());
99		}
100
101	+	/**
102	+	* size changes when elements added and removed
103	+	*/
104		public void testSize() {
105		LinkedList q = populatedQueue(SIZE);
106		for (int i = 0; i < SIZE; ++i) {
107	<	assertEquals(SIZE-i, q.size());
107	>	assertEquals(SIZE - i, q.size());
108		q.remove();
109		}
110		for (int i = 0; i < SIZE; ++i) {
#	Line 79 | Line 113 | public class LinkedListTest extends JSR1
113		}
114		}
115
116	<	public void testOfferNull(){
117	<	try {
118	<	LinkedList q = new LinkedList();
119	<	q.offer(null);
120	<	} catch (NullPointerException ie) {
121	<	fail("should not throw NPE");
122	<	}
116	>	/**
117	>	* offer(null) succeeds
118	>	*/
119	>	public void testOfferNull() {
120	>	LinkedList q = new LinkedList();
121	>	q.offer(null);
122	>	assertNull(q.get(0));
123	>	assertTrue(q.contains(null));
124		}
125
126	+	/**
127	+	* Offer succeeds
128	+	*/
129		public void testOffer() {
130		LinkedList q = new LinkedList();
131		assertTrue(q.offer(new Integer(0)));
132		assertTrue(q.offer(new Integer(1)));
133		}
134
135	<	public void testAdd(){
135	>	/**
136	>	* add succeeds
137	>	*/
138	>	public void testAdd() {
139		LinkedList q = new LinkedList();
140		for (int i = 0; i < SIZE; ++i) {
141		assertEquals(i, q.size());
#	Line 102 | Line 143 | public class LinkedListTest extends JSR1
143		}
144		}
145
146	<	public void testAddAll1(){
146	>	/**
147	>	* addAll(null) throws NPE
148	>	*/
149	>	public void testAddAll1() {
150	>	LinkedList q = new LinkedList();
151		try {
107	–	LinkedList q = new LinkedList();
152		q.addAll(null);
153	<	fail("Cannot add null collection");
154	<	}
111	<	catch (NullPointerException success) {}
153	>	shouldThrow();
154	>	} catch (NullPointerException success) {}
155		}
156
157	<	public void testAddAll5(){
157	>	/**
158	>	* Queue contains all elements, in traversal order, of successful addAll
159	>	*/
160	>	public void testAddAll5() {
161	>	Integer[] empty = new Integer[0];
162	>	Integer[] ints = new Integer[SIZE];
163	>	for (int i = 0; i < SIZE; ++i)
164	>	ints[i] = i;
165	>	LinkedList q = new LinkedList();
166	>	assertFalse(q.addAll(Arrays.asList(empty)));
167	>	assertTrue(q.addAll(Arrays.asList(ints)));
168	>	for (int i = 0; i < SIZE; ++i)
169	>	assertEquals(ints[i], q.poll());
170	>	}
171	>
172	>	/**
173	>	* addAll with too large an index throws IOOBE
174	>	*/
175	>	public void testAddAll2_IndexOutOfBoundsException() {
176	>	LinkedList l = new LinkedList();
177	>	l.add(new Object());
178	>	LinkedList m = new LinkedList();
179	>	m.add(new Object());
180		try {
181	<	Integer[] empty = new Integer[0];
182	<	Integer[] ints = new Integer[SIZE];
183	<	for (int i = 0; i < SIZE; ++i)
119	<	ints[i] = new Integer(i);
120	<	LinkedList q = new LinkedList();
121	<	assertFalse(q.addAll(Arrays.asList(empty)));
122	<	assertTrue(q.addAll(Arrays.asList(ints)));
123	<	for (int i = 0; i < SIZE; ++i)
124	<	assertEquals(ints[i], q.poll());
125	<	}
126	<	finally {}
181	>	l.addAll(4,m);
182	>	shouldThrow();
183	>	} catch (IndexOutOfBoundsException success) {}
184		}
185
186	<	public void testPoll(){
186	>	/**
187	>	* addAll with negative index throws IOOBE
188	>	*/
189	>	public void testAddAll4_BadIndex() {
190	>	LinkedList l = new LinkedList();
191	>	l.add(new Object());
192	>	LinkedList m = new LinkedList();
193	>	m.add(new Object());
194	>	try {
195	>	l.addAll(-1,m);
196	>	shouldThrow();
197	>	} catch (IndexOutOfBoundsException success) {}
198	>	}
199	>
200	>	/**
201	>	* poll succeeds unless empty
202	>	*/
203	>	public void testPoll() {
204		LinkedList q = populatedQueue(SIZE);
205		for (int i = 0; i < SIZE; ++i) {
206	<	assertEquals(i, ((Integer)q.poll()).intValue());
206	>	assertEquals(i, q.poll());
207		}
208	<	assertNull(q.poll());
208	>	assertNull(q.poll());
209		}
210
211	<	public void testPeek(){
211	>	/**
212	>	* peek returns next element, or null if empty
213	>	*/
214	>	public void testPeek() {
215		LinkedList q = populatedQueue(SIZE);
216		for (int i = 0; i < SIZE; ++i) {
217	<	assertEquals(i, ((Integer)q.peek()).intValue());
218	<	q.poll();
217	>	assertEquals(i, q.peek());
218	>	assertEquals(i, q.poll());
219		assertTrue(q.peek() == null ||
220	<	i != ((Integer)q.peek()).intValue());
220	>	!q.peek().equals(i));
221		}
222	<	assertNull(q.peek());
222	>	assertNull(q.peek());
223		}
224
225	<	public void testElement(){
225	>	/**
226	>	* element returns next element, or throws NSEE if empty
227	>	*/
228	>	public void testElement() {
229		LinkedList q = populatedQueue(SIZE);
230		for (int i = 0; i < SIZE; ++i) {
231	<	assertEquals(i, ((Integer)q.element()).intValue());
232	<	q.poll();
231	>	assertEquals(i, q.element());
232	>	assertEquals(i, q.poll());
233		}
234		try {
235		q.element();
236	<	fail("no such element");
237	<	}
158	<	catch (NoSuchElementException success) {}
236	>	shouldThrow();
237	>	} catch (NoSuchElementException success) {}
238		}
239
240	<	public void testRemove(){
240	>	/**
241	>	* remove removes next element, or throws NSEE if empty
242	>	*/
243	>	public void testRemove() {
244		LinkedList q = populatedQueue(SIZE);
245		for (int i = 0; i < SIZE; ++i) {
246	<	assertEquals(i, ((Integer)q.remove()).intValue());
246	>	assertEquals(i, q.remove());
247		}
248		try {
249		q.remove();
250	<	fail("remove should throw");
251	<	} catch (NoSuchElementException success){
170	<	}
250	>	shouldThrow();
251	>	} catch (NoSuchElementException success) {}
252		}
253
254	<	public void testRemoveElement(){
254	>	/**
255	>	* remove(x) removes x and returns true if present
256	>	*/
257	>	public void testRemoveElement() {
258		LinkedList q = populatedQueue(SIZE);
259	<	for (int i = 1; i < SIZE; i+=2) {
260	<	assertTrue(q.remove(new Integer(i)));
261	<	}
262	<	for (int i = 0; i < SIZE; i+=2) {
263	<	assertTrue(q.remove(new Integer(i)));
264	<	assertFalse(q.remove(new Integer(i+1)));
259	>	for (int i = 1; i < SIZE; i += 2) {
260	>	assertTrue(q.contains(i));
261	>	assertTrue(q.remove((Integer)i));
262	>	assertFalse(q.contains(i));
263	>	assertTrue(q.contains(i - 1));
264	>	}
265	>	for (int i = 0; i < SIZE; i += 2) {
266	>	assertTrue(q.contains(i));
267	>	assertTrue(q.remove((Integer)i));
268	>	assertFalse(q.contains(i));
269	>	assertFalse(q.remove((Integer)(i + 1)));
270	>	assertFalse(q.contains(i + 1));
271		}
272		assertTrue(q.isEmpty());
273		}
274	<
275	<	public void testContains(){
274	>
275	>	/**
276	>	* contains(x) reports true when elements added but not yet removed
277	>	*/
278	>	public void testContains() {
279		LinkedList q = populatedQueue(SIZE);
280		for (int i = 0; i < SIZE; ++i) {
281		assertTrue(q.contains(new Integer(i)));
#	Line 191 | Line 284 | public class LinkedListTest extends JSR1
284		}
285		}
286
287	<	public void testClear(){
287	>	/**
288	>	* clear removes all elements
289	>	*/
290	>	public void testClear() {
291		LinkedList q = populatedQueue(SIZE);
292		q.clear();
293		assertTrue(q.isEmpty());
294		assertEquals(0, q.size());
295	<	q.add(new Integer(1));
295	>	assertTrue(q.add(new Integer(1)));
296		assertFalse(q.isEmpty());
297		q.clear();
298		assertTrue(q.isEmpty());
299		}
300
301	<	public void testContainsAll(){
301	>	/**
302	>	* containsAll(c) is true when c contains a subset of elements
303	>	*/
304	>	public void testContainsAll() {
305		LinkedList q = populatedQueue(SIZE);
306		LinkedList p = new LinkedList();
307		for (int i = 0; i < SIZE; ++i) {
308		assertTrue(q.containsAll(p));
309		assertFalse(p.containsAll(q));
310	<	p.add(new Integer(i));
310	>	assertTrue(p.add(new Integer(i)));
311		}
312		assertTrue(p.containsAll(q));
313		}
314
315	<	public void testRetainAll(){
315	>	/**
316	>	* retainAll(c) retains only those elements of c and reports true if changed
317	>	*/
318	>	public void testRetainAll() {
319		LinkedList q = populatedQueue(SIZE);
320		LinkedList p = populatedQueue(SIZE);
321		for (int i = 0; i < SIZE; ++i) {
#	Line 224 | Line 326 | public class LinkedListTest extends JSR1
326		assertTrue(changed);
327
328		assertTrue(q.containsAll(p));
329	<	assertEquals(SIZE-i, q.size());
329	>	assertEquals(SIZE - i, q.size());
330		p.remove();
331		}
332		}
333
334	<	public void testRemoveAll(){
334	>	/**
335	>	* removeAll(c) removes only those elements of c and reports true if changed
336	>	*/
337	>	public void testRemoveAll() {
338		for (int i = 1; i < SIZE; ++i) {
339		LinkedList q = populatedQueue(SIZE);
340		LinkedList p = populatedQueue(i);
341		assertTrue(q.removeAll(p));
342	<	assertEquals(SIZE-i, q.size());
342	>	assertEquals(SIZE - i, q.size());
343		for (int j = 0; j < i; ++j) {
344	<	Integer I = (Integer)(p.remove());
345	<	assertFalse(q.contains(I));
344	>	Integer x = (Integer)(p.remove());
345	>	assertFalse(q.contains(x));
346		}
347		}
348		}
349
350	<	public void testToArray(){
350	>	/**
351	>	* toArray contains all elements in FIFO order
352	>	*/
353	>	public void testToArray() {
354		LinkedList q = populatedQueue(SIZE);
355	<	Object[] o = q.toArray();
356	<	Arrays.sort(o);
357	<	for(int i = 0; i < o.length; i++)
250	<	assertEquals(o[i], q.poll());
355	>	Object[] o = q.toArray();
356	>	for (int i = 0; i < o.length; i++)
357	>	assertSame(o[i], q.poll());
358		}
359
360	<	public void testToArray2(){
361	<	LinkedList q = populatedQueue(SIZE);
362	<	Integer[] ints = new Integer[SIZE];
363	<	ints = (Integer[])q.toArray(ints);
364	<	Arrays.sort(ints);
365	<	for(int i = 0; i < ints.length; i++)
366	<	assertEquals(ints[i], q.poll());
360	>	/**
361	>	* toArray(a) contains all elements in FIFO order
362	>	*/
363	>	public void testToArray2() {
364	>	LinkedList<Integer> q = populatedQueue(SIZE);
365	>	Integer[] ints = new Integer[SIZE];
366	>	Integer[] array = q.toArray(ints);
367	>	assertSame(ints, array);
368	>	for (int i = 0; i < ints.length; i++)
369	>	assertSame(ints[i], q.poll());
370		}
371	<
372	<	public void testIterator(){
371	>
372	>	/**
373	>	* toArray(null) throws NullPointerException
374	>	*/
375	>	public void testToArray_NullArg() {
376	>	LinkedList l = new LinkedList();
377	>	l.add(new Object());
378	>	try {
379	>	l.toArray(null);
380	>	shouldThrow();
381	>	} catch (NullPointerException success) {}
382	>	}
383	>
384	>	/**
385	>	* toArray(incompatible array type) throws ArrayStoreException
386	>	*/
387	>	public void testToArray1_BadArg() {
388	>	LinkedList l = new LinkedList();
389	>	l.add(new Integer(5));
390	>	try {
391	>	l.toArray(new String[10]);
392	>	shouldThrow();
393	>	} catch (ArrayStoreException success) {}
394	>	}
395	>
396	>	/**
397	>	* iterator iterates through all elements
398	>	*/
399	>	public void testIterator() {
400		LinkedList q = populatedQueue(SIZE);
401	<	int i = 0;
402	<	Iterator it = q.iterator();
403	<	while(it.hasNext()) {
401	>	Iterator it = q.iterator();
402	>	int i;
403	>	for (i = 0; it.hasNext(); i++)
404		assertTrue(q.contains(it.next()));
268	–	++i;
269	–	}
405		assertEquals(i, SIZE);
406	+	assertIteratorExhausted(it);
407		}
408
409	<	public void testIteratorOrdering() {
409	>	/**
410	>	* iterator of empty collection has no elements
411	>	*/
412	>	public void testEmptyIterator() {
413	>	assertIteratorExhausted(new LinkedList().iterator());
414	>	}
415
416	+	/**
417	+	* iterator ordering is FIFO
418	+	*/
419	+	public void testIteratorOrdering() {
420		final LinkedList q = new LinkedList();
276	–
421		q.add(new Integer(1));
422		q.add(new Integer(2));
423		q.add(new Integer(3));
280	–
424		int k = 0;
425		for (Iterator it = q.iterator(); it.hasNext();) {
426	<	int i = ((Integer)(it.next())).intValue();
284	<	assertEquals("items should come out in order", ++k, i);
426	>	assertEquals(++k, it.next());
427		}
428
429	<	assertEquals("should go through 3 elements", 3, k);
429	>	assertEquals(3, k);
430		}
431
432	<	public void testIteratorRemove () {
432	>	/**
433	>	* iterator.remove removes current element
434	>	*/
435	>	public void testIteratorRemove() {
436		final LinkedList q = new LinkedList();
292	–
437		q.add(new Integer(1));
438		q.add(new Integer(2));
439		q.add(new Integer(3));
296	–
440		Iterator it = q.iterator();
441	<	it.next();
441	>	assertEquals(1, it.next());
442		it.remove();
300	–
443		it = q.iterator();
444	<	assertEquals(it.next(), new Integer(2));
445	<	assertEquals(it.next(), new Integer(3));
444	>	assertEquals(2, it.next());
445	>	assertEquals(3, it.next());
446		assertFalse(it.hasNext());
447		}
448
449	+	/**
450	+	* Descending iterator iterates through all elements
451	+	*/
452	+	public void testDescendingIterator() {
453	+	LinkedList q = populatedQueue(SIZE);
454	+	int i = 0;
455	+	Iterator it = q.descendingIterator();
456	+	while (it.hasNext()) {
457	+	assertTrue(q.contains(it.next()));
458	+	++i;
459	+	}
460	+	assertEquals(i, SIZE);
461	+	assertFalse(it.hasNext());
462	+	try {
463	+	it.next();
464	+	shouldThrow();
465	+	} catch (NoSuchElementException success) {}
466	+	}
467	+
468	+	/**
469	+	* Descending iterator ordering is reverse FIFO
470	+	*/
471	+	public void testDescendingIteratorOrdering() {
472	+	final LinkedList q = new LinkedList();
473	+	q.add(new Integer(3));
474	+	q.add(new Integer(2));
475	+	q.add(new Integer(1));
476	+	int k = 0;
477	+	for (Iterator it = q.descendingIterator(); it.hasNext();) {
478	+	assertEquals(++k, it.next());
479	+	}
480	+
481	+	assertEquals(3, k);
482	+	}
483
484	<	public void testToString(){
484	>	/**
485	>	* descendingIterator.remove removes current element
486	>	*/
487	>	public void testDescendingIteratorRemove() {
488	>	final LinkedList q = new LinkedList();
489	>	q.add(three);
490	>	q.add(two);
491	>	q.add(one);
492	>	Iterator it = q.descendingIterator();
493	>	it.next();
494	>	it.remove();
495	>	it = q.descendingIterator();
496	>	assertSame(it.next(), two);
497	>	assertSame(it.next(), three);
498	>	assertFalse(it.hasNext());
499	>	}
500	>
501	>	/**
502	>	* toString contains toStrings of elements
503	>	*/
504	>	public void testToString() {
505		LinkedList q = populatedQueue(SIZE);
506		String s = q.toString();
507		for (int i = 0; i < SIZE; ++i) {
508	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
508	>	assertTrue(s.contains(String.valueOf(i)));
509		}
510	<	}
510	>	}
511
512	<	public void testAddFirst(){
512	>	/**
513	>	* peek returns element inserted with addFirst
514	>	*/
515	>	public void testAddFirst() {
516		LinkedList q = populatedQueue(3);
517	<	q.addFirst(new Integer(4));
518	<	assertEquals(new Integer(4),q.get(0));
519	<	}
517	>	q.addFirst(four);
518	>	assertSame(four, q.peek());
519	>	}
520
521	<	public void testAddLast(){
521	>	/**
522	>	* peekFirst returns element inserted with push
523	>	*/
524	>	public void testPush() {
525		LinkedList q = populatedQueue(3);
526	<	q.addLast(new Integer(3));
527	<	assertEquals(new Integer(3),q.get(3));
526	>	q.push(four);
527	>	assertSame(four, q.peekFirst());
528		}
529	<
530	<	public void testGetFirst() {
531	<	LinkedList q = populatedQueue(3);
532	<	assertEquals(new Integer(0),q.getFirst());
533	<	}
534	<
535	<	public void testGetLast() {
536	<	LinkedList q = populatedQueue(3);
537	<	assertEquals(new Integer(2),q.getLast());
529	>
530	>	/**
531	>	* pop removes next element, or throws NSEE if empty
532	>	*/
533	>	public void testPop() {
534	>	LinkedList q = populatedQueue(SIZE);
535	>	for (int i = 0; i < SIZE; ++i) {
536	>	assertEquals(i, q.pop());
537	>	}
538	>	try {
539	>	q.pop();
540	>	shouldThrow();
541	>	} catch (NoSuchElementException success) {}
542		}
543	<
544	<	public void testIndexOf(){
545	<	LinkedList q = populatedQueue(3);
546	<	assertEquals(0,q.indexOf(new Integer(0)));
547	<	assertEquals(1,q.indexOf(new Integer(1)));
548	<	assertEquals(2,q.indexOf(new Integer(2)));
549	<	assertEquals(-1, q.indexOf("not there"));
543	>
544	>	/**
545	>	* OfferFirst succeeds
546	>	*/
547	>	public void testOfferFirst() {
548	>	LinkedList q = new LinkedList();
549	>	assertTrue(q.offerFirst(new Integer(0)));
550	>	assertTrue(q.offerFirst(new Integer(1)));
551		}
552
553	<	public void testLastIndexOf(){
554	<	LinkedList q = populatedQueue(3);
555	<	q.add(new Integer(2));
556	<	assertEquals(3,q.lastIndexOf(new Integer(2)));
557	<	assertEquals(-1, q.lastIndexOf("not there"));
553	>	/**
554	>	* OfferLast succeeds
555	>	*/
556	>	public void testOfferLast() {
557	>	LinkedList q = new LinkedList();
558	>	assertTrue(q.offerLast(new Integer(0)));
559	>	assertTrue(q.offerLast(new Integer(1)));
560		}
561	<
562	<	public void testSet(){
563	<	LinkedList q = populatedQueue(3);
564	<	q.set(0,(new Integer(1)));
565	<	assertFalse(q.contains(new Integer(0)));
566	<	assertEquals(new Integer(1), q.get(0));
567	<	}
568	<
569	<
570	<	public void testGetFirst_NoSuchElementException(){
362	<	try {
363	<	LinkedList l = new LinkedList();
364	<	l.getFirst();
365	<	fail("First Element");
366	<	}
367	<	catch(NoSuchElementException success) {}
368	<	}
369	<
370	<	public void testRemoveFirst() {
371	<	try {
372	<	LinkedList l = new LinkedList();
373	<	l.removeFirst();
374	<	fail("R: First Element");
375	<	}
376	<	catch(NoSuchElementException success) {}
377	<	}
378	<
379	<	public void testRemoveLast() {
380	<	try {
381	<	LinkedList l = new LinkedList();
382	<	l.removeLast();
383	<	fail("R: Last Element");
384	<	}
385	<	catch(NoSuchElementException success) {}
386	<	}
387	<
388	<	public void testGetLast_NoSuchElementException(){
389	<	try {
390	<	LinkedList l = new LinkedList();
391	<	l.getLast();
392	<	fail("Last Element");
393	<	}
394	<	catch(NoSuchElementException success) {}
561	>
562	>	/**
563	>	* pollLast succeeds unless empty
564	>	*/
565	>	public void testPollLast() {
566	>	LinkedList q = populatedQueue(SIZE);
567	>	for (int i = SIZE - 1; i >= 0; --i) {
568	>	assertEquals(i, q.pollLast());
569	>	}
570	>	assertNull(q.pollLast());
571		}
572
573	+	/**
574	+	* peekFirst returns next element, or null if empty
575	+	*/
576	+	public void testPeekFirst() {
577	+	LinkedList q = populatedQueue(SIZE);
578	+	for (int i = 0; i < SIZE; ++i) {
579	+	assertEquals(i, q.peekFirst());
580	+	assertEquals(i, q.pollFirst());
581	+	assertTrue(q.peekFirst() == null ||
582	+	!q.peekFirst().equals(i));
583	+	}
584	+	assertNull(q.peekFirst());
585	+	}
586
587	<	public void testAddAll_NullPointerException(){
588	<	try {
589	<	LinkedList l = new LinkedList();
590	<	l.addAll((Collection)null);
591	<	fail("Add All Failed");
592	<	}
593	<	catch(NullPointerException success){}
594	<	}
595	<
596	<
597	<	public void testAddAll1_OutOfBounds() {
598	<	try {
410	<	LinkedList l = new LinkedList();
411	<	l.addAll(4,new LinkedList());
412	<	fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");
413	<	}
414	<	catch(IndexOutOfBoundsException  success) {}
587	>	/**
588	>	* peekLast returns next element, or null if empty
589	>	*/
590	>	public void testPeekLast() {
591	>	LinkedList q = populatedQueue(SIZE);
592	>	for (int i = SIZE - 1; i >= 0; --i) {
593	>	assertEquals(i, q.peekLast());
594	>	assertEquals(i, q.pollLast());
595	>	assertTrue(q.peekLast() == null ||
596	>	!q.peekLast().equals(i));
597	>	}
598	>	assertNull(q.peekLast());
599		}
600	<
601	<
602	<	public void testAddAll2_IndexOutOfBoundsException() {
603	<	try {
604	<	LinkedList l = new LinkedList();
605	<	l.add(new Object());
606	<	LinkedList m = new LinkedList();
607	<	m.add(new Object());
608	<	l.addAll(4,m);
609	<	fail("Add All Failed " + l.size());
610	<	}catch(IndexOutOfBoundsException  success) {}
600	>
601	>	public void testFirstElement() {
602	>	LinkedList q = populatedQueue(SIZE);
603	>	for (int i = 0; i < SIZE; ++i) {
604	>	assertEquals(i, q.getFirst());
605	>	assertEquals(i, q.pollFirst());
606	>	}
607	>	try {
608	>	q.getFirst();
609	>	shouldThrow();
610	>	} catch (NoSuchElementException success) {}
611		}
612
613	<	public void testAddAll4_BadIndex() {
614	<	try {
615	<	LinkedList l = new LinkedList();
616	<	l.add(new Object());
617	<	LinkedList m = new LinkedList();
618	<	m.add(new Object());
619	<	l.addAll(-1,m);
620	<	fail("Add All Failed " + l.size());
621	<	}catch(IndexOutOfBoundsException  success){}
622	<	}
623	<
624	<	public void testget1() {
625	<	try {
626	<	LinkedList l = new LinkedList();
443	<	l.add(new Object());
444	<	l.get(-1);
445	<	fail("get Failed - l.get(-1)");
446	<	}catch(IndexOutOfBoundsException  success) {}
447	<	}
448	<
449	<	public void testget2() {
450	<	try {
451	<	LinkedList l = new LinkedList();
452	<	l.add(new Object());
453	<	l.get(5);
454	<	fail("get Failed - l.get(5) l.size(): " + l.size());
455	<	}catch(IndexOutOfBoundsException  success){}
456	<	}
457	<
458	<	public void testset1() {
459	<	try {
460	<	LinkedList l = new LinkedList();
461	<	l.add(new Object());
462	<	l.set(-1,new Object());
463	<	fail("set failed - l.set(-1,...)" + l.size());
464	<	}catch(IndexOutOfBoundsException  success){}
465	<	}
466	<
467	<	public void testset2() {
468	<	try {
469	<	LinkedList l = new LinkedList();
470	<	l.add(new Object());
471	<	l.set(5,new Object());
472	<	fail("set failed = l.set(5,..) l.size():" + l.size());
473	<	}catch(IndexOutOfBoundsException  success){}
474	<	}
475	<
476	<	public void testadd1() {
477	<	try {
478	<	LinkedList l = new LinkedList();
479	<	l.add(new Object());
480	<	l.add(-1,new Object());
481	<	fail("Add Failed - l.add(-1) l.size(): " + l.size());
482	<	}catch(IndexOutOfBoundsException  success){}
483	<	}
484	<
485	<	public void add2(){
486	<	try {
487	<	LinkedList l = new LinkedList();
488	<	l.add(new Object());
489	<	l.add(5,new Object());
490	<	fail("Add Failed  l.add(f,...)");
491	<	}catch(IndexOutOfBoundsException  success) {}
492	<	}
493	<
494	<	public void testremove(){
495	<	try {
496	<	LinkedList l = new LinkedList();
497	<	l.add(new Object());
498	<	l.remove(-1);
499	<	fail("Remove Failed l.remove(-1); l.size():" + l.size());
500	<	}catch(IndexOutOfBoundsException  success){}
501	<	}
502	<
503	<	public void testremove1(){
504	<	try {
505	<	LinkedList l = new LinkedList();
506	<	l.add(new Object());
507	<	l.remove(5);
508	<	fail("Remove Failed l.remove(5); l.size():" + l.size());
509	<	}catch(IndexOutOfBoundsException  success){}
510	<	}
511	<
512	<
513	<	public void testremove2(){
514	<	try{
515	<	LinkedList l = new LinkedList();
516	<	l.remove();
517	<	fail("LinkedList - Object remove() should throw a NoSuchElementException");
518	<	}catch(NoSuchElementException e){}
519	<	}
520	<
521	<	public void testlistIt1() {
522	<	try {
523	<	LinkedList l = new LinkedList();
524	<	l.add(new Object());
525	<	l.listIterator(5);
526	<	fail("l.listIterator(5) l.size():" + l.size());
527	<	}catch(IndexOutOfBoundsException  success){}
528	<	}
529	<
530	<	public void testlistIt2() {
531	<	try {
532	<	LinkedList l = new LinkedList();
533	<	l.add(new Object());
534	<	l.listIterator(-1);
535	<	fail("l.listIterator(-1) l.size():" + l.size());
536	<	}catch(IndexOutOfBoundsException  success){}
537	<	}
538	<
539	<	public void testlistIt3() {
540	<	try {
541	<	LinkedList l = new LinkedList();
542	<	l.add(new Object());
543	<	ListIterator a = l.listIterator(0);
544	<	l.removeFirst();
545	<	a.next();
546	<	fail("l.listIterator(-1) l.size():" + l.size());
547	<	}catch(ConcurrentModificationException success){}
548	<	}
549	<
550	<	public void testToArray_BadArg() {
551	<	try {
552	<	LinkedList l = new LinkedList();
553	<	l.add(new Object());
554	<	Object o[] = l.toArray(null);
555	<	fail("l.toArray(null) did not throw an exception");
556	<	}catch(NullPointerException success){}
613	>	/**
614	>	* getLast returns next element, or throws NSEE if empty
615	>	*/
616	>	public void testLastElement() {
617	>	LinkedList q = populatedQueue(SIZE);
618	>	for (int i = SIZE - 1; i >= 0; --i) {
619	>	assertEquals(i, q.getLast());
620	>	assertEquals(i, q.pollLast());
621	>	}
622	>	try {
623	>	q.getLast();
624	>	shouldThrow();
625	>	} catch (NoSuchElementException success) {}
626	>	assertNull(q.peekLast());
627		}
628
629	<	public void testToArray1_BadArg() {
630	<	try {
631	<	LinkedList l = new LinkedList();
632	<	l.add(new Integer(5));
633	<	Object o[] = l.toArray(new String[10] );
634	<	fail("l.toArray(String[] f) did not throw an exception, an Integer was added");
635	<	}catch(ArrayStoreException  success){}
629	>	/**
630	>	* removeFirstOccurrence(x) removes x and returns true if present
631	>	*/
632	>	public void testRemoveFirstOccurrence() {
633	>	LinkedList q = populatedQueue(SIZE);
634	>	for (int i = 1; i < SIZE; i += 2) {
635	>	assertTrue(q.removeFirstOccurrence(new Integer(i)));
636	>	}
637	>	for (int i = 0; i < SIZE; i += 2) {
638	>	assertTrue(q.removeFirstOccurrence(new Integer(i)));
639	>	assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
640	>	}
641	>	assertTrue(q.isEmpty());
642	>	}
643	>
644	>	/**
645	>	* removeLastOccurrence(x) removes x and returns true if present
646	>	*/
647	>	public void testRemoveLastOccurrence() {
648	>	LinkedList q = populatedQueue(SIZE);
649	>	for (int i = 1; i < SIZE; i += 2) {
650	>	assertTrue(q.removeLastOccurrence(new Integer(i)));
651	>	}
652	>	for (int i = 0; i < SIZE; i += 2) {
653	>	assertTrue(q.removeLastOccurrence(new Integer(i)));
654	>	assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
655	>	}
656	>	assertTrue(q.isEmpty());
657		}
658
659		}

Diff Legend

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