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.13 by jsr166, Sat Nov 21 02:07:27 2009 UTC vs.
Revision 1.43 by jsr166, Mon Nov 14 23:57:55 2016 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.*;
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<Integer>();
48		assertTrue(q.isEmpty());
49		for (int i = 0; i < n; ++i)
50		assertTrue(q.offer(new Integer(i)));
51		assertFalse(q.isEmpty());
52		assertEquals(n, q.size());
53	+	assertEquals((Integer) 0, q.peekFirst());
54	+	assertEquals((Integer) (n - 1), q.peekLast());
55		return q;
56		}
57
#	Line 45 | Line 67 | public class LinkedListTest extends JSR1
67		*/
68		public void testConstructor3() {
69		try {
70	<	LinkedList q = new LinkedList((Collection)null);
70	>	new LinkedList((Collection)null);
71		shouldThrow();
72	<	}
51	<	catch (NullPointerException success) {}
72	>	} catch (NullPointerException success) {}
73		}
74
75		/**
76		* Queue contains all elements of collection used to initialize
56	–
77		*/
78		public void testConstructor6() {
79	<	try {
80	<	Integer[] ints = new Integer[SIZE];
81	<	for (int i = 0; i < SIZE; ++i)
82	<	ints[i] = new Integer(i);
83	<	LinkedList q = new LinkedList(Arrays.asList(ints));
84	<	for (int i = 0; i < SIZE; ++i)
65	<	assertEquals(ints[i], q.poll());
66	<	}
67	<	finally {}
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		/**
#	Line 87 | Line 104 | public class LinkedListTest extends JSR1
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 100 | Line 117 | public class LinkedListTest extends JSR1
117		* offer(null) succeeds
118		*/
119		public void testOfferNull() {
120	<	try {
121	<	LinkedList q = new LinkedList();
122	<	q.offer(null);
123	<	} catch (NullPointerException ie) {
107	<	unexpectedException();
108	<	}
120	>	LinkedList q = new LinkedList();
121	>	q.offer(null);
122	>	assertNull(q.get(0));
123	>	assertTrue(q.contains(null));
124		}
125
126		/**
#	Line 132 | Line 147 | public class LinkedListTest extends JSR1
147		* addAll(null) throws NPE
148		*/
149		public void testAddAll1() {
150	+	LinkedList q = new LinkedList();
151		try {
136	–	LinkedList q = new LinkedList();
152		q.addAll(null);
153		shouldThrow();
154	<	}
140	<	catch (NullPointerException success) {}
154	>	} catch (NullPointerException success) {}
155		}
156
157		/**
158		* Queue contains all elements, in traversal order, of successful addAll
159		*/
160		public void testAddAll5() {
161	<	try {
162	<	Integer[] empty = new Integer[0];
163	<	Integer[] ints = new Integer[SIZE];
164	<	for (int i = 0; i < SIZE; ++i)
165	<	ints[i] = new Integer(i);
166	<	LinkedList q = new LinkedList();
167	<	assertFalse(q.addAll(Arrays.asList(empty)));
168	<	assertTrue(q.addAll(Arrays.asList(ints)));
169	<	for (int i = 0; i < SIZE; ++i)
156	<	assertEquals(ints[i], q.poll());
157	<	}
158	<	finally {}
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 {
166	–	LinkedList l = new LinkedList();
167	–	l.add(new Object());
168	–	LinkedList m = new LinkedList();
169	–	m.add(new Object());
181		l.addAll(4,m);
182		shouldThrow();
183	<	} catch (IndexOutOfBoundsException  success) {}
183	>	} catch (IndexOutOfBoundsException success) {}
184		}
185
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 {
180	–	LinkedList l = new LinkedList();
181	–	l.add(new Object());
182	–	LinkedList m = new LinkedList();
183	–	m.add(new Object());
195		l.addAll(-1,m);
196		shouldThrow();
197	<	} catch (IndexOutOfBoundsException  success) {}
197	>	} catch (IndexOutOfBoundsException success) {}
198		}
199
200		/**
201	<	*  poll succeeds unless empty
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());
209		}
210
211		/**
212	<	*  peek returns next element, or null if empty
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());
223		}
#	Line 217 | Line 228 | public class LinkedListTest extends JSR1
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		shouldThrow();
237	<	}
227	<	catch (NoSuchElementException success) {}
237	>	} catch (NoSuchElementException success) {}
238		}
239
240		/**
241	<	*  remove removes next element, or throws NSEE if empty
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		shouldThrow();
251	<	} catch (NoSuchElementException success) {
242	<	}
251	>	} catch (NoSuchElementException success) {}
252		}
253
254		/**
#	Line 247 | Line 256 | public class LinkedListTest extends JSR1
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		}
#	Line 277 | Line 292 | public class LinkedListTest extends JSR1
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());
#	Line 292 | Line 307 | public class LinkedListTest extends JSR1
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		}
#	Line 311 | 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		}
#	Line 324 | Line 339 | public class LinkedListTest extends JSR1
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		/**
351	<	*  toArray contains all elements
351	>	* toArray contains all elements in FIFO order
352		*/
353		public void testToArray() {
354		LinkedList q = populatedQueue(SIZE);
355		Object[] o = q.toArray();
341	–	Arrays.sort(o);
356		for (int i = 0; i < o.length; i++)
357	<	assertEquals(o[i], q.poll());
357	>	assertSame(o[i], q.poll());
358		}
359
360		/**
361	<	*  toArray(a) contains all elements
361	>	* toArray(a) contains all elements in FIFO order
362		*/
363		public void testToArray2() {
364	<	LinkedList q = populatedQueue(SIZE);
364	>	LinkedList<Integer> q = populatedQueue(SIZE);
365		Integer[] ints = new Integer[SIZE];
366	<	ints = (Integer[])q.toArray(ints);
367	<	Arrays.sort(ints);
366	>	Integer[] array = q.toArray(ints);
367	>	assertSame(ints, array);
368		for (int i = 0; i < ints.length; i++)
369	<	assertEquals(ints[i], q.poll());
369	>	assertSame(ints[i], q.poll());
370		}
371
372		/**
373	<	* toArray(null) throws NPE
373	>	* toArray(null) throws NullPointerException
374		*/
375	<	public void testToArray_BadArg() {
375	>	public void testToArray_NullArg() {
376	>	LinkedList l = new LinkedList();
377	>	l.add(new Object());
378		try {
379	<	LinkedList l = new LinkedList();
364	<	l.add(new Object());
365	<	Object o[] = l.toArray(null);
379	>	l.toArray(null);
380		shouldThrow();
381		} catch (NullPointerException success) {}
382		}
383
384		/**
385	<	* toArray with incompatable aray type throws CCE
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	<	LinkedList l = new LinkedList();
376	<	l.add(new Integer(5));
377	<	Object o[] = l.toArray(new String[10] );
391	>	l.toArray(new String[10]);
392		shouldThrow();
393	<	} catch (ArrayStoreException  success) {}
393	>	} catch (ArrayStoreException success) {}
394		}
395
396		/**
397	<	*  iterator iterates through all elements
397	>	* iterator iterates through all elements
398		*/
399		public void testIterator() {
400		LinkedList q = populatedQueue(SIZE);
387	–	int i = 0;
401		Iterator it = q.iterator();
402	<	while (it.hasNext()) {
402	>	int i;
403	>	for (i = 0; it.hasNext(); i++)
404		assertTrue(q.contains(it.next()));
391	–	++i;
392	–	}
405		assertEquals(i, SIZE);
406	+	assertIteratorExhausted(it);
407	+	}
408	+
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
417	>	* iterator ordering is FIFO
418		*/
419		public void testIteratorOrdering() {
420		final LinkedList q = new LinkedList();
#	Line 403 | Line 423 | public class LinkedListTest extends JSR1
423		q.add(new Integer(3));
424		int k = 0;
425		for (Iterator it = q.iterator(); it.hasNext();) {
426	<	int i = ((Integer)(it.next())).intValue();
407	<	assertEquals(++k, i);
426	>	assertEquals(++k, it.next());
427		}
428
429		assertEquals(3, k);
#	Line 413 | Line 432 | public class LinkedListTest extends JSR1
432		/**
433		* iterator.remove removes current element
434		*/
435	<	public void testIteratorRemove () {
435	>	public void testIteratorRemove() {
436		final LinkedList q = new LinkedList();
437		q.add(new Integer(1));
438		q.add(new Integer(2));
439		q.add(new Integer(3));
440		Iterator it = q.iterator();
441	<	it.next();
441	>	assertEquals(1, it.next());
442		it.remove();
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
450	>	* Descending iterator iterates through all elements
451		*/
452		public void testDescendingIterator() {
453		LinkedList q = populatedQueue(SIZE);
#	Line 442 | Line 461 | public class LinkedListTest extends JSR1
461		assertFalse(it.hasNext());
462		try {
463		it.next();
464	<	} catch (NoSuchElementException success) {
465	<	}
464	>	shouldThrow();
465	>	} catch (NoSuchElementException success) {}
466		}
467
468		/**
469	<	*  Descending iterator ordering is reverse FIFO
469	>	* Descending iterator ordering is reverse FIFO
470		*/
471		public void testDescendingIteratorOrdering() {
472		final LinkedList q = new LinkedList();
#	Line 456 | Line 475 | public class LinkedListTest extends JSR1
475		q.add(new Integer(1));
476		int k = 0;
477		for (Iterator it = q.descendingIterator(); it.hasNext();) {
478	<	int i = ((Integer)(it.next())).intValue();
460	<	assertEquals(++k, i);
478	>	assertEquals(++k, it.next());
479		}
480
481		assertEquals(3, k);
#	Line 466 | Line 484 | public class LinkedListTest extends JSR1
484		/**
485		* descendingIterator.remove removes current element
486		*/
487	<	public void testDescendingIteratorRemove () {
487	>	public void testDescendingIteratorRemove() {
488		final LinkedList q = new LinkedList();
489	<	q.add(new Integer(3));
490	<	q.add(new Integer(2));
491	<	q.add(new Integer(1));
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	<	assertEquals(it.next(), new Integer(2));
497	<	assertEquals(it.next(), new Integer(3));
496	>	assertSame(it.next(), two);
497	>	assertSame(it.next(), three);
498		assertFalse(it.hasNext());
499		}
500
483	–
501		/**
502		* toString contains toStrings of elements
503		*/
#	Line 488 | Line 505 | public class LinkedListTest extends JSR1
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		}
511
#	Line 498 | Line 515 | public class LinkedListTest extends JSR1
515		public void testAddFirst() {
516		LinkedList q = populatedQueue(3);
517		q.addFirst(four);
518	<	assertEquals(four,q.peek());
518	>	assertSame(four, q.peek());
519		}
520
521		/**
#	Line 506 | Line 523 | public class LinkedListTest extends JSR1
523		*/
524		public void testPush() {
525		LinkedList q = populatedQueue(3);
509	–	q.pollLast();
526		q.push(four);
527	<	assertEquals(four,q.peekFirst());
527	>	assertSame(four, q.peekFirst());
528		}
529
530		/**
531	<	*  pop removes next element, or throws NSEE if empty
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, ((Integer)q.pop()).intValue());
536	>	assertEquals(i, q.pop());
537		}
538		try {
539		q.pop();
540		shouldThrow();
541	<	} catch (NoSuchElementException success) {
526	<	}
541	>	} catch (NoSuchElementException success) {}
542		}
543
544		/**
#	Line 545 | Line 560 | public class LinkedListTest extends JSR1
560		}
561
562		/**
563	<	*  pollLast succeeds unless empty
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, ((Integer)q.pollLast()).intValue());
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
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, ((Integer)q.peekFirst()).intValue());
580	<	q.pollFirst();
579	>	assertEquals(i, q.peekFirst());
580	>	assertEquals(i, q.pollFirst());
581		assertTrue(q.peekFirst() == null ||
582	<	i != ((Integer)q.peekFirst()).intValue());
582	>	!q.peekFirst().equals(i));
583		}
584		assertNull(q.peekFirst());
585		}
586
572	–
587		/**
588	<	*  peekLast returns next element, or null if empty
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, ((Integer)q.peekLast()).intValue());
594	<	q.pollLast();
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	<	i != ((Integer)q.peekLast()).intValue());
596	>	!q.peekLast().equals(i));
597		}
598		assertNull(q.peekLast());
599		}
#	Line 587 | Line 601 | public class LinkedListTest extends JSR1
601		public void testFirstElement() {
602		LinkedList q = populatedQueue(SIZE);
603		for (int i = 0; i < SIZE; ++i) {
604	<	assertEquals(i, ((Integer)q.getFirst()).intValue());
605	<	q.pollFirst();
604	>	assertEquals(i, q.getFirst());
605	>	assertEquals(i, q.pollFirst());
606		}
607		try {
608		q.getFirst();
609		shouldThrow();
610	<	}
597	<	catch (NoSuchElementException success) {}
610	>	} catch (NoSuchElementException success) {}
611		}
612
613		/**
614	<	*  getLast returns next element, or throws NSEE if empty
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, ((Integer)q.getLast()).intValue());
620	<	q.pollLast();
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	<	}
613	<	catch (NoSuchElementException success) {}
625	>	} catch (NoSuchElementException success) {}
626		assertNull(q.peekLast());
627		}
628
#	Line 619 | Line 631 | public class LinkedListTest extends JSR1
631		*/
632		public void testRemoveFirstOccurrence() {
633		LinkedList q = populatedQueue(SIZE);
634	<	for (int i = 1; i < SIZE; i+=2) {
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) {
637	>	for (int i = 0; i < SIZE; i += 2) {
638		assertTrue(q.removeFirstOccurrence(new Integer(i)));
639	<	assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
639	>	assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
640		}
641		assertTrue(q.isEmpty());
642		}
#	Line 634 | Line 646 | public class LinkedListTest extends JSR1
646		*/
647		public void testRemoveLastOccurrence() {
648		LinkedList q = populatedQueue(SIZE);
649	<	for (int i = 1; i < SIZE; i+=2) {
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) {
652	>	for (int i = 0; i < SIZE; i += 2) {
653		assertTrue(q.removeLastOccurrence(new Integer(i)));
654	<	assertFalse(q.removeLastOccurrence(new Integer(i+1)));
654	>	assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
655		}
656		assertTrue(q.isEmpty());
657		}

Diff Legend

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