--- jsr166/src/test/tck/LinkedListTest.java	2003/09/14 20:42:40	1.3
+++ jsr166/src/test/tck/LinkedListTest.java	2015/05/24 01:42:14	1.40
@@ -1,61 +1,75 @@
 /*
- * 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/publicdomain/zero/1.0/
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
+ * Pat Fisher, Mike Judd.
  */
 
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
 
 public class LinkedListTest extends JSR166TestCase {
     public static void main(String[] args) {
-	junit.textui.TestRunner.run (suite());	
+        main(suite(), args);
     }
 
     public static Test suite() {
-	return new TestSuite(LinkedListTest.class);
+        return new TestSuite(LinkedListTest.class);
     }
 
     /**
-     * Create a queue of given size containing consecutive
+     * Returns a new queue of given size containing consecutive
      * Integers 0 ... n.
      */
-    private LinkedList populatedQueue(int n) {
-        LinkedList q = new LinkedList();
+    private LinkedList<Integer> populatedQueue(int n) {
+        LinkedList<Integer> q = new LinkedList<Integer>();
         assertTrue(q.isEmpty());
-	for(int i = 0; i < n; ++i)
-	    assertTrue(q.offer(new Integer(i)));
+        for (int i = 0; i < n; ++i)
+            assertTrue(q.offer(new Integer(i)));
         assertFalse(q.isEmpty());
-	assertEquals(n, q.size());
+        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");
-        }
-        catch (NullPointerException success) {}
+            new LinkedList((Collection)null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
-    public void testConstructor6(){
-        try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            LinkedList q = new LinkedList(Arrays.asList(ints));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+    /**
+     * Queue contains all elements of collection used to initialize
+     */
+    public void testConstructor6() {
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = i;
+        LinkedList q = new LinkedList(Arrays.asList(ints));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.poll());
     }
 
+    /**
+     * isEmpty is true before add, false after
+     */
     public void testEmpty() {
         LinkedList q = new LinkedList();
         assertTrue(q.isEmpty());
@@ -67,10 +81,13 @@ 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) {
-            assertEquals(SIZE-i, q.size());
+            assertEquals(SIZE - i, q.size());
             q.remove();
         }
         for (int i = 0; i < SIZE; ++i) {
@@ -79,22 +96,29 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testOfferNull(){
-	try {
-            LinkedList q = new LinkedList();
-            q.offer(null);
-        } catch (NullPointerException ie) { 
-            fail("should not throw NPE");
-        }   
+    /**
+     * offer(null) succeeds
+     */
+    public void testOfferNull() {
+        LinkedList q = new LinkedList();
+        q.offer(null);
+        assertNull(q.get(0));
+        assertTrue(q.contains(null));
     }
 
+    /**
+     * 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,87 +126,139 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testAddAll1(){
+    /**
+     * addAll(null) throws NPE
+     */
+    public void testAddAll1() {
+        LinkedList q = new LinkedList();
         try {
-            LinkedList q = new LinkedList();
             q.addAll(null);
-            fail("Cannot add null collection");
-        }
-        catch (NullPointerException success) {}
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * Queue contains all elements, in traversal order, of successful addAll
+     */
+    public void testAddAll5() {
+        Integer[] empty = new Integer[0];
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = i;
+        LinkedList q = new LinkedList();
+        assertFalse(q.addAll(Arrays.asList(empty)));
+        assertTrue(q.addAll(Arrays.asList(ints)));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.poll());
     }
 
-    public void testAddAll5(){
+    /**
+     * addAll with too large an index throws IOOBE
+     */
+    public void testAddAll2_IndexOutOfBoundsException() {
+        LinkedList l = new LinkedList();
+        l.add(new Object());
+        LinkedList m = new LinkedList();
+        m.add(new Object());
         try {
-            Integer[] empty = new Integer[0];
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            LinkedList q = new LinkedList();
-            assertFalse(q.addAll(Arrays.asList(empty)));
-            assertTrue(q.addAll(Arrays.asList(ints)));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+            l.addAll(4,m);
+            shouldThrow();
+        } catch (IndexOutOfBoundsException success) {}
+    }
+
+    /**
+     * addAll with negative index throws IOOBE
+     */
+    public void testAddAll4_BadIndex() {
+        LinkedList l = new LinkedList();
+        l.add(new Object());
+        LinkedList m = new LinkedList();
+        m.add(new Object());
+        try {
+            l.addAll(-1,m);
+            shouldThrow();
+        } catch (IndexOutOfBoundsException success) {}
     }
 
-    public void testPoll(){
+    /**
+     * poll succeeds unless empty
+     */
+    public void testPoll() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.poll()).intValue());
+            assertEquals(i, q.poll());
         }
-	assertNull(q.poll());
+        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());
-            q.poll();
+            assertEquals(i, q.peek());
+            assertEquals(i, q.poll());
             assertTrue(q.peek() == null ||
-                       i != ((Integer)q.peek()).intValue());
+                       !q.peek().equals(i));
         }
-	assertNull(q.peek());
+        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());
-            q.poll();
+            assertEquals(i, q.element());
+            assertEquals(i, q.poll());
         }
         try {
             q.element();
-            fail("no such element");
-        }
-        catch (NoSuchElementException success) {}
+            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());
+            assertEquals(i, q.remove());
         }
         try {
             q.remove();
-            fail("remove should throw");
-        } catch (NoSuchElementException success){
-	}   
+            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)));
-        }
-        for (int i = 0; i < SIZE; i+=2) {
-            assertTrue(q.remove(new Integer(i)));
-            assertFalse(q.remove(new Integer(i+1)));
+        for (int i = 1; i < SIZE; i += 2) {
+            assertTrue(q.contains(i));
+            assertTrue(q.remove((Integer)i));
+            assertFalse(q.contains(i));
+            assertTrue(q.contains(i - 1));
+        }
+        for (int i = 0; i < SIZE; i += 2) {
+            assertTrue(q.contains(i));
+            assertTrue(q.remove((Integer)i));
+            assertFalse(q.contains(i));
+            assertFalse(q.remove((Integer)(i + 1)));
+            assertFalse(q.contains(i + 1));
         }
         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,29 +267,38 @@ public class LinkedListTest extends JSR1
         }
     }
 
-    public void testClear(){
+    /**
+     * clear removes all elements
+     */
+    public void testClear() {
         LinkedList q = populatedQueue(SIZE);
         q.clear();
         assertTrue(q.isEmpty());
         assertEquals(0, q.size());
-        q.add(new Integer(1));
+        assertTrue(q.add(new Integer(1)));
         assertFalse(q.isEmpty());
         q.clear();
         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) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
-            p.add(new Integer(i));
+            assertTrue(p.add(new Integer(i)));
         }
         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) {
@@ -224,345 +309,334 @@ public class LinkedListTest extends JSR1
                 assertTrue(changed);
 
             assertTrue(q.containsAll(p));
-            assertEquals(SIZE-i, q.size());
+            assertEquals(SIZE - i, q.size());
             p.remove();
         }
     }
 
-    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);
             assertTrue(q.removeAll(p));
-            assertEquals(SIZE-i, q.size());
+            assertEquals(SIZE - i, q.size());
             for (int j = 0; j < i; ++j) {
-                Integer I = (Integer)(p.remove());
-                assertFalse(q.contains(I));
+                Integer x = (Integer)(p.remove());
+                assertFalse(q.contains(x));
             }
         }
     }
 
-    public void testToArray(){
+    /**
+     * toArray contains all elements in FIFO order
+     */
+    public void testToArray() {
         LinkedList q = populatedQueue(SIZE);
-	Object[] o = q.toArray();
-        Arrays.sort(o);
-	for(int i = 0; i < o.length; i++)
-	    assertEquals(o[i], q.poll());
+        Object[] o = q.toArray();
+        for (int i = 0; i < o.length; i++)
+            assertSame(o[i], q.poll());
     }
 
-    public void testToArray2(){
-        LinkedList q = populatedQueue(SIZE);
-	Integer[] ints = new Integer[SIZE];
-	ints = (Integer[])q.toArray(ints);
-        Arrays.sort(ints);
-        for(int i = 0; i < ints.length; i++)
-            assertEquals(ints[i], q.poll());
+    /**
+     * toArray(a) contains all elements in FIFO order
+     */
+    public void testToArray2() {
+        LinkedList<Integer> q = populatedQueue(SIZE);
+        Integer[] ints = new Integer[SIZE];
+        Integer[] array = q.toArray(ints);
+        assertSame(ints, array);
+        for (int i = 0; i < ints.length; i++)
+            assertSame(ints[i], q.poll());
+    }
+
+    /**
+     * toArray(null) throws NullPointerException
+     */
+    public void testToArray_NullArg() {
+        LinkedList l = new LinkedList();
+        l.add(new Object());
+        try {
+            l.toArray(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
-    
-    public void testIterator(){
+
+    /**
+     * toArray(incompatible array type) throws ArrayStoreException
+     */
+    public void testToArray1_BadArg() {
+        LinkedList l = new LinkedList();
+        l.add(new Integer(5));
+        try {
+            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();
-        while(it.hasNext()) {
+        Iterator it = q.iterator();
+        int i;
+        for (i = 0; it.hasNext(); i++)
             assertTrue(q.contains(it.next()));
-            ++i;
-        }
         assertEquals(i, SIZE);
+        assertIteratorExhausted(it);
     }
 
-    public void testIteratorOrdering() {
+    /**
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(new LinkedList().iterator());
+    }
 
+    /**
+     * 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, it.next());
         }
 
-        assertEquals("should go through 3 elements", 3, k);
+        assertEquals(3, k);
     }
 
-    public void testIteratorRemove () {
+    /**
+     * 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();
+        assertEquals(1, it.next());
         it.remove();
-
         it = q.iterator();
-        assertEquals(it.next(), new Integer(2));
-        assertEquals(it.next(), new Integer(3));
+        assertEquals(2, it.next());
+        assertEquals(3, it.next());
+        assertFalse(it.hasNext());
+    }
+
+    /**
+     * Descending iterator iterates through all elements
+     */
+    public void testDescendingIterator() {
+        LinkedList q = populatedQueue(SIZE);
+        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();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
+    }
+
+    /**
+     * Descending iterator ordering is reverse FIFO
+     */
+    public void testDescendingIteratorOrdering() {
+        final LinkedList q = new LinkedList();
+        q.add(new Integer(3));
+        q.add(new Integer(2));
+        q.add(new Integer(1));
+        int k = 0;
+        for (Iterator it = q.descendingIterator(); it.hasNext();) {
+            assertEquals(++k, it.next());
+        }
+
+        assertEquals(3, k);
     }
 
+    /**
+     * descendingIterator.remove removes current element
+     */
+    public void testDescendingIteratorRemove() {
+        final LinkedList q = new LinkedList();
+        q.add(three);
+        q.add(two);
+        q.add(one);
+        Iterator it = q.descendingIterator();
+        it.next();
+        it.remove();
+        it = q.descendingIterator();
+        assertSame(it.next(), two);
+        assertSame(it.next(), three);
+        assertFalse(it.hasNext());
+    }
 
-    public void testToString(){
+    /**
+     * 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);
+            assertTrue(s.contains(String.valueOf(i)));
         }
-    }        
+    }
 
-    public void testAddFirst(){
+    /**
+     * peek returns element inserted with addFirst
+     */
+    public void testAddFirst() {
         LinkedList q = populatedQueue(3);
-	q.addFirst(new Integer(4));
-	assertEquals(new Integer(4),q.get(0));
-    }	
+        q.addFirst(four);
+        assertSame(four, q.peek());
+    }
 
-    public void testAddLast(){
+    /**
+     * peekFirst returns element inserted with push
+     */
+    public void testPush() {
         LinkedList q = populatedQueue(3);
-	q.addLast(new Integer(3));
-	assertEquals(new Integer(3),q.get(3));
+        q.push(four);
+        assertSame(four, q.peekFirst());
     }
-    
-    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());
+
+    /**
+     * 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, q.pop());
+        }
+        try {
+            q.pop();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
     }
-    
-    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")); 
+
+    /**
+     * OfferFirst succeeds
+     */
+    public void testOfferFirst() {
+        LinkedList q = new LinkedList();
+        assertTrue(q.offerFirst(new Integer(0)));
+        assertTrue(q.offerFirst(new Integer(1)));
     }
 
-    public void testLastIndexOf(){
-        LinkedList q = populatedQueue(3);
-        q.add(new Integer(2));
-	assertEquals(3,q.lastIndexOf(new Integer(2)));
-        assertEquals(-1, q.lastIndexOf("not there"));
+    /**
+     * OfferLast succeeds
+     */
+    public void testOfferLast() {
+        LinkedList q = new LinkedList();
+        assertTrue(q.offerLast(new Integer(0)));
+        assertTrue(q.offerLast(new Integer(1)));
     }
-    
-    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));
-    }
-    
-
-    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) {}
-    }
-    
-    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) {}
+
+    /**
+     * pollLast succeeds unless empty
+     */
+    public void testPollLast() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = SIZE - 1; i >= 0; --i) {
+            assertEquals(i, q.pollLast());
+        }
+        assertNull(q.pollLast());
     }
 
+    /**
+     * peekFirst returns next element, or null if empty
+     */
+    public void testPeekFirst() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            assertEquals(i, q.peekFirst());
+            assertEquals(i, q.pollFirst());
+            assertTrue(q.peekFirst() == null ||
+                       !q.peekFirst().equals(i));
+        }
+        assertNull(q.peekFirst());
+    }
 
-    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) {}
+    /**
+     * 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, q.peekLast());
+            assertEquals(i, q.pollLast());
+            assertTrue(q.peekLast() == null ||
+                       !q.peekLast().equals(i));
+        }
+        assertNull(q.peekLast());
     }
-    
-    
-    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) {}
+
+    public void testFirstElement() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            assertEquals(i, q.getFirst());
+            assertEquals(i, q.pollFirst());
+        }
+        try {
+            q.getFirst();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
     }
 
-    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){}
-    }
-
-    public void testget1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.get(-1);
-	    fail("get Failed - l.get(-1)");
-	}catch(IndexOutOfBoundsException  success) {}	
-    }
-
-    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){}	
-    }
-
-    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){}	
-    }
-
-    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){}	
-    }
-
-    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){}	
-    }
-
-    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) {}	
-    }
-
-    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){}	
-    }
-
-    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 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){}
-    }
-
-    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){}
+    /**
+     * 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, q.getLast());
+            assertEquals(i, q.pollLast());
+        }
+        try {
+            q.getLast();
+            shouldThrow();
+        } catch (NoSuchElementException success) {}
+        assertNull(q.peekLast());
     }
 
-    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){}
+    /**
+     * 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());
+    }
+
+    /**
+     * 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());
     }
 
 }