--- jsr166/src/test/tck/LinkedListTest.java	2003/09/14 20:42:40	1.3
+++ jsr166/src/test/tck/LinkedListTest.java	2009/11/02 20:28:31	1.10
@@ -1,8 +1,9 @@
 /*
- * Written by members of JCP JSR-166 Expert Group and released to the
- * public domain. Use, modify, and redistribute this code in any way
- * without acknowledgement. Other contributors include Andrew Wright,
- * Jeffrey Hayes, Pat Fischer, Mike Judd.
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
+ * Pat Fisher, Mike Judd.
  */
 
 import junit.framework.*;
@@ -11,7 +12,7 @@ import java.util.concurrent.*;
 
 public class LinkedListTest extends JSR166TestCase {
     public static void main(String[] args) {
-	junit.textui.TestRunner.run (suite());	
+	junit.textui.TestRunner.run (suite());
     }
 
     public static Test suite() {
@@ -31,20 +32,30 @@ public class LinkedListTest extends JSR1
 	assertEquals(n, q.size());
         return q;
     }
- 
-    public void testConstructor1(){
+
+    /**
+     * new queue is empty
+     */
+    public void testConstructor1() {
         assertEquals(0, new LinkedList().size());
     }
 
+    /**
+     * Initializing from null Collection throws NPE
+     */
     public void testConstructor3() {
         try {
             LinkedList q = new LinkedList((Collection)null);
-            fail("Cannot make from null collection");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
 
-    public void testConstructor6(){
+    /**
+     * Queue contains all elements of collection used to initialize
+
+     */
+    public void testConstructor6() {
         try {
             Integer[] ints = new Integer[SIZE];
             for (int i = 0; i < SIZE; ++i)
@@ -56,6 +67,9 @@ public class LinkedListTest extends JSR1
         finally {}
     }
 
+    /**
+     * isEmpty is true before add, false after
+     */
     public void testEmpty() {
         LinkedList q = new LinkedList();
         assertTrue(q.isEmpty());
@@ -67,6 +81,9 @@ public class LinkedListTest extends JSR1
         assertTrue(q.isEmpty());
     }
 
+    /**
+     * size changes when elements added and removed
+     */
     public void testSize() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
@@ -79,22 +96,31 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testOfferNull(){
+    /**
+     * offer(null) succeeds
+     */
+    public void testOfferNull() {
 	try {
             LinkedList q = new LinkedList();
             q.offer(null);
-        } catch (NullPointerException ie) { 
-            fail("should not throw NPE");
-        }   
+        } catch (NullPointerException ie) {
+            unexpectedException();
+        }
     }
 
+    /**
+     * Offer succeeds
+     */
     public void testOffer() {
         LinkedList q = new LinkedList();
         assertTrue(q.offer(new Integer(0)));
         assertTrue(q.offer(new Integer(1)));
     }
 
-    public void testAdd(){
+    /**
+     * add succeeds
+     */
+    public void testAdd() {
         LinkedList q = new LinkedList();
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, q.size());
@@ -102,16 +128,22 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testAddAll1(){
+    /**
+     * addAll(null) throws NPE
+     */
+    public void testAddAll1() {
         try {
             LinkedList q = new LinkedList();
             q.addAll(null);
-            fail("Cannot add null collection");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
 
-    public void testAddAll5(){
+    /**
+     * Queue contains all elements, in traversal order, of successful addAll
+     */
+    public void testAddAll5() {
         try {
             Integer[] empty = new Integer[0];
             Integer[] ints = new Integer[SIZE];
@@ -126,7 +158,38 @@ public class LinkedListTest extends JSR1
         finally {}
     }
 
-    public void testPoll(){
+    /**
+     * addAll with too large an index throws IOOBE
+     */
+    public void testAddAll2_IndexOutOfBoundsException() {
+	try {
+	    LinkedList l = new LinkedList();
+	    l.add(new Object());
+	    LinkedList m = new LinkedList();
+	    m.add(new Object());
+	    l.addAll(4,m);
+	    shouldThrow();
+	} catch(IndexOutOfBoundsException  success) {}
+    }
+
+    /**
+     * addAll with negative index throws IOOBE
+     */
+    public void testAddAll4_BadIndex() {
+	try {
+	    LinkedList l = new LinkedList();
+	    l.add(new Object());
+	    LinkedList m = new LinkedList();
+	    m.add(new Object());
+	    l.addAll(-1,m);
+	    shouldThrow();
+	} catch(IndexOutOfBoundsException  success){}
+    }
+
+    /**
+     *  poll succeeds unless empty
+     */
+    public void testPoll() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.poll()).intValue());
@@ -134,7 +197,10 @@ public class LinkedListTest extends JSR1
 	assertNull(q.poll());
     }
 
-    public void testPeek(){
+    /**
+     *  peek returns next element, or null if empty
+     */
+    public void testPeek() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.peek()).intValue());
@@ -145,7 +211,10 @@ public class LinkedListTest extends JSR1
 	assertNull(q.peek());
     }
 
-    public void testElement(){
+    /**
+     * element returns next element, or throws NSEE if empty
+     */
+    public void testElement() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.element()).intValue());
@@ -153,24 +222,30 @@ public class LinkedListTest extends JSR1
         }
         try {
             q.element();
-            fail("no such element");
+            shouldThrow();
         }
         catch (NoSuchElementException success) {}
     }
 
-    public void testRemove(){
+    /**
+     *  remove removes next element, or throws NSEE if empty
+     */
+    public void testRemove() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.remove()).intValue());
         }
         try {
             q.remove();
-            fail("remove should throw");
+            shouldThrow();
         } catch (NoSuchElementException success){
-	}   
+	}
     }
 
-    public void testRemoveElement(){
+    /**
+     * remove(x) removes x and returns true if present
+     */
+    public void testRemoveElement() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 1; i < SIZE; i+=2) {
             assertTrue(q.remove(new Integer(i)));
@@ -181,8 +256,11 @@ public class LinkedListTest extends JSR1
         }
         assertTrue(q.isEmpty());
     }
-	
-    public void testContains(){
+
+    /**
+     * contains(x) reports true when elements added but not yet removed
+     */
+    public void testContains() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.contains(new Integer(i)));
@@ -191,7 +269,10 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testClear(){
+    /**
+     * clear removes all elements
+     */
+    public void testClear() {
         LinkedList q = populatedQueue(SIZE);
         q.clear();
         assertTrue(q.isEmpty());
@@ -202,7 +283,10 @@ public class LinkedListTest extends JSR1
         assertTrue(q.isEmpty());
     }
 
-    public void testContainsAll(){
+    /**
+     * containsAll(c) is true when c contains a subset of elements
+     */
+    public void testContainsAll() {
         LinkedList q = populatedQueue(SIZE);
         LinkedList p = new LinkedList();
         for (int i = 0; i < SIZE; ++i) {
@@ -213,7 +297,10 @@ public class LinkedListTest extends JSR1
         assertTrue(p.containsAll(q));
     }
 
-    public void testRetainAll(){
+    /**
+     * retainAll(c) retains only those elements of c and reports true if changed
+     */
+    public void testRetainAll() {
         LinkedList q = populatedQueue(SIZE);
         LinkedList p = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
@@ -229,7 +316,10 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testRemoveAll(){
+    /**
+     * removeAll(c) removes only those elements of c and reports true if changed
+     */
+    public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
             LinkedList q = populatedQueue(SIZE);
             LinkedList p = populatedQueue(i);
@@ -242,7 +332,10 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testToArray(){
+    /**
+     *  toArray contains all elements
+     */
+    public void testToArray() {
         LinkedList q = populatedQueue(SIZE);
 	Object[] o = q.toArray();
         Arrays.sort(o);
@@ -250,7 +343,10 @@ public class LinkedListTest extends JSR1
 	    assertEquals(o[i], q.poll());
     }
 
-    public void testToArray2(){
+    /**
+     *  toArray(a) contains all elements
+     */
+    public void testToArray2() {
         LinkedList q = populatedQueue(SIZE);
 	Integer[] ints = new Integer[SIZE];
 	ints = (Integer[])q.toArray(ints);
@@ -258,8 +354,35 @@ public class LinkedListTest extends JSR1
         for(int i = 0; i < ints.length; i++)
             assertEquals(ints[i], q.poll());
     }
-    
-    public void testIterator(){
+
+    /**
+     * toArray(null) throws NPE
+     */
+    public void testToArray_BadArg() {
+	try {
+	    LinkedList l = new LinkedList();
+	    l.add(new Object());
+	    Object o[] = l.toArray(null);
+	    shouldThrow();
+	} catch(NullPointerException success){}
+    }
+
+    /**
+     * toArray with incompatable aray type throws CCE
+     */
+    public void testToArray1_BadArg() {
+	try {
+	    LinkedList l = new LinkedList();
+	    l.add(new Integer(5));
+	    Object o[] = l.toArray(new String[10] );
+	    shouldThrow();
+	} catch(ArrayStoreException  success){}
+    }
+
+    /**
+     *  iterator iterates through all elements
+     */
+    public void testIterator() {
         LinkedList q = populatedQueue(SIZE);
         int i = 0;
 	Iterator it = q.iterator();
@@ -270,299 +393,255 @@ public class LinkedListTest extends JSR1
         assertEquals(i, SIZE);
     }
 
+    /**
+     *  iterator ordering is FIFO
+     */
     public void testIteratorOrdering() {
-
         final LinkedList q = new LinkedList();
-
         q.add(new Integer(1));
         q.add(new Integer(2));
         q.add(new Integer(3));
-
         int k = 0;
         for (Iterator it = q.iterator(); it.hasNext();) {
             int i = ((Integer)(it.next())).intValue();
-            assertEquals("items should come out in order", ++k, i);
+            assertEquals(++k, i);
         }
 
-        assertEquals("should go through 3 elements", 3, k);
+        assertEquals(3, k);
     }
 
+    /**
+     * iterator.remove removes current element
+     */
     public void testIteratorRemove () {
         final LinkedList q = new LinkedList();
-
         q.add(new Integer(1));
         q.add(new Integer(2));
         q.add(new Integer(3));
-
         Iterator it = q.iterator();
         it.next();
         it.remove();
-
         it = q.iterator();
         assertEquals(it.next(), new Integer(2));
         assertEquals(it.next(), new Integer(3));
         assertFalse(it.hasNext());
     }
 
-
-    public void testToString(){
+    /**
+     *  Descending iterator iterates through all elements
+     */
+    public void testDescendingIterator() {
         LinkedList q = populatedQueue(SIZE);
-        String s = q.toString();
-        for (int i = 0; i < SIZE; ++i) {
-            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
+        int i = 0;
+	Iterator it = q.descendingIterator();
+        while(it.hasNext()) {
+            assertTrue(q.contains(it.next()));
+            ++i;
+        }
+        assertEquals(i, SIZE);
+        assertFalse(it.hasNext());
+        try {
+            it.next();
+        } catch(NoSuchElementException success) {
         }
-    }        
-
-    public void testAddFirst(){
-        LinkedList q = populatedQueue(3);
-	q.addFirst(new Integer(4));
-	assertEquals(new Integer(4),q.get(0));
-    }	
-
-    public void testAddLast(){
-        LinkedList q = populatedQueue(3);
-	q.addLast(new Integer(3));
-	assertEquals(new Integer(3),q.get(3));
-    }
-    
-    public void testGetFirst() {
-        LinkedList q = populatedQueue(3);
-        assertEquals(new Integer(0),q.getFirst());
-    }	
-    
-    public void testGetLast() {
-        LinkedList q = populatedQueue(3);
-        assertEquals(new Integer(2),q.getLast());
-    }
-    
-    public void testIndexOf(){
-        LinkedList q = populatedQueue(3);
-	assertEquals(0,q.indexOf(new Integer(0)));
-	assertEquals(1,q.indexOf(new Integer(1)));
-	assertEquals(2,q.indexOf(new Integer(2)));
-        assertEquals(-1, q.indexOf("not there")); 
     }
 
-    public void testLastIndexOf(){
-        LinkedList q = populatedQueue(3);
+    /**
+     *  Descending iterator ordering is reverse FIFO
+     */
+    public void testDescendingIteratorOrdering() {
+        final LinkedList q = new LinkedList();
+        q.add(new Integer(3));
         q.add(new Integer(2));
-	assertEquals(3,q.lastIndexOf(new Integer(2)));
-        assertEquals(-1, q.lastIndexOf("not there"));
-    }
-    
-    public void testSet(){
-        LinkedList q = populatedQueue(3);
-	q.set(0,(new Integer(1)));
-	assertFalse(q.contains(new Integer(0)));
-	assertEquals(new Integer(1), q.get(0));
-    }
-    
+        q.add(new Integer(1));
+        int k = 0;
+        for (Iterator it = q.descendingIterator(); it.hasNext();) {
+            int i = ((Integer)(it.next())).intValue();
+            assertEquals(++k, i);
+        }
 
-    public void testGetFirst_NoSuchElementException(){
-	try {
-	    LinkedList l = new LinkedList();
-	    l.getFirst();
-	    fail("First Element"); 
-	}
-	catch(NoSuchElementException success) {}
-    }
-    
-    public void testRemoveFirst() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.removeFirst();
-	    fail("R: First Element"); 
-	}
-	catch(NoSuchElementException success) {}
+        assertEquals(3, k);
     }
-    
-    public void testRemoveLast() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.removeLast();
-	    fail("R: Last Element");  
-	}
-	catch(NoSuchElementException success) {}
-    }
-    
-    public void testGetLast_NoSuchElementException(){
-	try {
-	    LinkedList l = new LinkedList();
-	    l.getLast();
-	    fail("Last Element");  
-	}
-	catch(NoSuchElementException success) {}
+
+    /**
+     * descendingIterator.remove removes current element
+     */
+    public void testDescendingIteratorRemove () {
+        final LinkedList q = new LinkedList();
+        q.add(new Integer(3));
+        q.add(new Integer(2));
+        q.add(new Integer(1));
+        Iterator it = q.descendingIterator();
+        it.next();
+        it.remove();
+        it = q.descendingIterator();
+        assertEquals(it.next(), new Integer(2));
+        assertEquals(it.next(), new Integer(3));
+        assertFalse(it.hasNext());
     }
 
 
-    public void testAddAll_NullPointerException(){
-	try {
-	    LinkedList l = new LinkedList(); 
-	    l.addAll((Collection)null);
-	    fail("Add All Failed");
-	}
-	catch(NullPointerException success){}
-    }
-    
-    
-    public void testAddAll1_OutOfBounds() {
-	try {
-	    LinkedList l = new LinkedList(); 
-	    l.addAll(4,new LinkedList());
-	    fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");
-	}
-	catch(IndexOutOfBoundsException  success) {}
-    }
-    
-    
-    public void testAddAll2_IndexOutOfBoundsException() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    LinkedList m = new LinkedList();
-	    m.add(new Object());
-	    l.addAll(4,m);
-	    fail("Add All Failed " + l.size());
-	}catch(IndexOutOfBoundsException  success) {}
+    /**
+     * toString contains toStrings of elements
+     */
+    public void testToString() {
+        LinkedList q = populatedQueue(SIZE);
+        String s = q.toString();
+        for (int i = 0; i < SIZE; ++i) {
+            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
+        }
     }
 
-    public void testAddAll4_BadIndex() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    LinkedList m = new LinkedList();
-	    m.add(new Object());
-	    l.addAll(-1,m);
-	    fail("Add All Failed " + l.size());
-	}catch(IndexOutOfBoundsException  success){}
+    /**
+     * peek returns element inserted with addFirst
+     */
+    public void testAddFirst() {
+        LinkedList q = populatedQueue(3);
+	q.addFirst(four);
+	assertEquals(four,q.peek());
     }
 
-    public void testget1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.get(-1);
-	    fail("get Failed - l.get(-1)");
-	}catch(IndexOutOfBoundsException  success) {}	
+    /**
+     * peekFirst returns element inserted with push
+     */
+    public void testPush() {
+        LinkedList q = populatedQueue(3);
+        q.pollLast();
+	q.push(four);
+	assertEquals(four,q.peekFirst());
     }
 
-    public void testget2() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.get(5);
-	    fail("get Failed - l.get(5) l.size(): " + l.size());
-	}catch(IndexOutOfBoundsException  success){}	
+    /**
+     *  pop removes next element, or throws NSEE if empty
+     */
+    public void testPop() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            assertEquals(i, ((Integer)q.pop()).intValue());
+        }
+        try {
+            q.pop();
+            shouldThrow();
+        } catch (NoSuchElementException success){
+	}
     }
 
-    public void testset1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.set(-1,new Object());
-	    fail("set failed - l.set(-1,...)" + l.size());
-	}catch(IndexOutOfBoundsException  success){}	
+    /**
+     * OfferFirst succeeds
+     */
+    public void testOfferFirst() {
+        LinkedList q = new LinkedList();
+        assertTrue(q.offerFirst(new Integer(0)));
+        assertTrue(q.offerFirst(new Integer(1)));
     }
 
-    public void testset2() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.set(5,new Object());
-	    fail("set failed = l.set(5,..) l.size():" + l.size());
-	}catch(IndexOutOfBoundsException  success){}	
+    /**
+     * OfferLast succeeds
+     */
+    public void testOfferLast() {
+        LinkedList q = new LinkedList();
+        assertTrue(q.offerLast(new Integer(0)));
+        assertTrue(q.offerLast(new Integer(1)));
     }
 
-    public void testadd1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.add(-1,new Object());
-	    fail("Add Failed - l.add(-1) l.size(): " + l.size());
-	}catch(IndexOutOfBoundsException  success){}	
+    /**
+     *  pollLast succeeds unless empty
+     */
+    public void testPollLast() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = SIZE-1; i >= 0; --i) {
+            assertEquals(i, ((Integer)q.pollLast()).intValue());
+        }
+	assertNull(q.pollLast());
     }
 
-    public void add2(){
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.add(5,new Object());
-	    fail("Add Failed  l.add(f,...)");
-	}catch(IndexOutOfBoundsException  success) {}	
+    /**
+     *  peekFirst returns next element, or null if empty
+     */
+    public void testPeekFirst() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            assertEquals(i, ((Integer)q.peekFirst()).intValue());
+            q.pollFirst();
+            assertTrue(q.peekFirst() == null ||
+                       i != ((Integer)q.peekFirst()).intValue());
+        }
+	assertNull(q.peekFirst());
     }
 
-    public void testremove(){
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.remove(-1);
-	    fail("Remove Failed l.remove(-1); l.size():" + l.size());
-	}catch(IndexOutOfBoundsException  success){}
-    }
-    
-    public void testremove1(){
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.remove(5);
-	    fail("Remove Failed l.remove(5); l.size():" + l.size());
-	}catch(IndexOutOfBoundsException  success){}
-    }
 
-     
-    public void testremove2(){
-        try{
-	    LinkedList l = new LinkedList();
-            l.remove();
-            fail("LinkedList - Object remove() should throw a NoSuchElementException");
-	}catch(NoSuchElementException e){}	
+    /**
+     *  peekLast returns next element, or null if empty
+     */
+    public void testPeekLast() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = SIZE-1; i >= 0; --i) {
+            assertEquals(i, ((Integer)q.peekLast()).intValue());
+            q.pollLast();
+            assertTrue(q.peekLast() == null ||
+                       i != ((Integer)q.peekLast()).intValue());
+        }
+	assertNull(q.peekLast());
     }
 
-    public void testlistIt1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.listIterator(5);
-	    fail("l.listIterator(5) l.size():" + l.size());
-	}catch(IndexOutOfBoundsException  success){}
-    }
-    
-    public void testlistIt2() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.listIterator(-1);
-	    fail("l.listIterator(-1) l.size():" + l.size());
-	}catch(IndexOutOfBoundsException  success){}
+    public void testFirstElement() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            assertEquals(i, ((Integer)q.getFirst()).intValue());
+            q.pollFirst();
+        }
+        try {
+            q.getFirst();
+            shouldThrow();
+        }
+        catch (NoSuchElementException success) {}
     }
-    
-    public void testlistIt3() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    ListIterator a = l.listIterator(0);
-	    l.removeFirst();
-	    a.next();
-	    fail("l.listIterator(-1) l.size():" + l.size());
-	}catch(ConcurrentModificationException success){}
+
+    /**
+     *  getLast returns next element, or throws NSEE if empty
+     */
+    public void testLastElement() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = SIZE-1; i >= 0; --i) {
+            assertEquals(i, ((Integer)q.getLast()).intValue());
+            q.pollLast();
+        }
+        try {
+            q.getLast();
+            shouldThrow();
+        }
+        catch (NoSuchElementException success) {}
+	assertNull(q.peekLast());
     }
 
-    public void testToArray_BadArg() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    Object o[] = l.toArray(null);
-	    fail("l.toArray(null) did not throw an exception");
-	}catch(NullPointerException success){}
+    /**
+     * removeFirstOccurrence(x) removes x and returns true if present
+     */
+    public void testRemoveFirstOccurrence() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 1; i < SIZE; i+=2) {
+            assertTrue(q.removeFirstOccurrence(new Integer(i)));
+        }
+        for (int i = 0; i < SIZE; i+=2) {
+            assertTrue(q.removeFirstOccurrence(new Integer(i)));
+            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
+        }
+        assertTrue(q.isEmpty());
     }
 
-    public void testToArray1_BadArg() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Integer(5));
-	    Object o[] = l.toArray(new String[10] );
-	    fail("l.toArray(String[] f) did not throw an exception, an Integer was added");
-	}catch(ArrayStoreException  success){}
+    /**
+     * removeLastOccurrence(x) removes x and returns true if present
+     */
+    public void testRemoveLastOccurrence() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 1; i < SIZE; i+=2) {
+            assertTrue(q.removeLastOccurrence(new Integer(i)));
+        }
+        for (int i = 0; i < SIZE; i+=2) {
+            assertTrue(q.removeLastOccurrence(new Integer(i)));
+            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
+        }
+        assertTrue(q.isEmpty());
     }
 
 }