--- jsr166/src/test/tck/LinkedListTest.java	2003/09/20 18:20:08	1.4
+++ jsr166/src/test/tck/LinkedListTest.java	2009/11/16 05:30:07	1.12
@@ -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() {
@@ -25,22 +26,22 @@ public class LinkedListTest extends JSR1
     private LinkedList populatedQueue(int n) {
         LinkedList q = new LinkedList();
         assertTrue(q.isEmpty());
-	for(int i = 0; i < n; ++i)
+	for (int i = 0; i < n; ++i)
 	    assertTrue(q.offer(new Integer(i)));
         assertFalse(q.isEmpty());
 	assertEquals(n, q.size());
         return q;
     }
- 
+
     /**
-     *
+     * new queue is empty
      */
     public void testConstructor1() {
         assertEquals(0, new LinkedList().size());
     }
 
     /**
-     *
+     * Initializing from null Collection throws NPE
      */
     public void testConstructor3() {
         try {
@@ -51,7 +52,8 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * Queue contains all elements of collection used to initialize
+
      */
     public void testConstructor6() {
         try {
@@ -66,7 +68,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * isEmpty is true before add, false after
      */
     public void testEmpty() {
         LinkedList q = new LinkedList();
@@ -80,7 +82,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * size changes when elements added and removed
      */
     public void testSize() {
         LinkedList q = populatedQueue(SIZE);
@@ -95,19 +97,19 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * offer(null) succeeds
      */
     public void testOfferNull() {
 	try {
             LinkedList q = new LinkedList();
             q.offer(null);
-        } catch (NullPointerException ie) { 
+        } catch (NullPointerException ie) {
             unexpectedException();
-        }   
+        }
     }
 
     /**
-     *
+     * Offer succeeds
      */
     public void testOffer() {
         LinkedList q = new LinkedList();
@@ -116,7 +118,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * add succeeds
      */
     public void testAdd() {
         LinkedList q = new LinkedList();
@@ -127,7 +129,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * addAll(null) throws NPE
      */
     public void testAddAll1() {
         try {
@@ -139,7 +141,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * Queue contains all elements, in traversal order, of successful addAll
      */
     public void testAddAll5() {
         try {
@@ -157,7 +159,35 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * 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);
@@ -168,7 +198,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     *  peek returns next element, or null if empty
      */
     public void testPeek() {
         LinkedList q = populatedQueue(SIZE);
@@ -182,7 +212,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * element returns next element, or throws NSEE if empty
      */
     public void testElement() {
         LinkedList q = populatedQueue(SIZE);
@@ -198,7 +228,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     *  remove removes next element, or throws NSEE if empty
      */
     public void testRemove() {
         LinkedList q = populatedQueue(SIZE);
@@ -208,12 +238,12 @@ public class LinkedListTest extends JSR1
         try {
             q.remove();
             shouldThrow();
-        } catch (NoSuchElementException success){
-	}   
+        } catch (NoSuchElementException success) {
+	}
     }
 
     /**
-     *
+     * remove(x) removes x and returns true if present
      */
     public void testRemoveElement() {
         LinkedList q = populatedQueue(SIZE);
@@ -226,9 +256,9 @@ public class LinkedListTest extends JSR1
         }
         assertTrue(q.isEmpty());
     }
-	
+
     /**
-     *
+     * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
         LinkedList q = populatedQueue(SIZE);
@@ -240,7 +270,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * clear removes all elements
      */
     public void testClear() {
         LinkedList q = populatedQueue(SIZE);
@@ -254,7 +284,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
         LinkedList q = populatedQueue(SIZE);
@@ -268,7 +298,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * retainAll(c) retains only those elements of c and reports true if changed
      */
     public void testRetainAll() {
         LinkedList q = populatedQueue(SIZE);
@@ -287,7 +317,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * removeAll(c) removes only those elements of c and reports true if changed
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
@@ -303,36 +333,60 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     *  toArray contains all elements
      */
     public void testToArray() {
         LinkedList q = populatedQueue(SIZE);
 	Object[] o = q.toArray();
         Arrays.sort(o);
-	for(int i = 0; i < o.length; i++)
+	for (int i = 0; i < o.length; i++)
 	    assertEquals(o[i], q.poll());
     }
 
     /**
-     *
+     *  toArray(a) contains all elements
      */
     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++)
+        for (int i = 0; i < ints.length; i++)
             assertEquals(ints[i], q.poll());
     }
-    
+
+    /**
+     * 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();
-        while(it.hasNext()) {
+        while (it.hasNext()) {
             assertTrue(q.contains(it.next()));
             ++i;
         }
@@ -340,16 +394,13 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     *  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();
@@ -360,371 +411,237 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *
+     * 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());
     }
 
-
     /**
-     *
+     *  Descending iterator iterates through all elements
      */
-    public void testToString() {
+    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")); 
     }
 
     /**
-     *
+     *  Descending iterator ordering is reverse FIFO
      */
-    public void testLastIndexOf() {
-        LinkedList q = populatedQueue(3);
+    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();
-	    shouldThrow();
-	}
-	catch(NoSuchElementException success) {}
-    }
-    
-    /**
-     *
-     */
-    public void testRemoveFirst() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.removeFirst();
-	    shouldThrow();
-	}
-	catch(NoSuchElementException success) {}
-    }
-    
-    /**
-     *
-     */
-    public void testRemoveLast() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.removeLast();
-	    shouldThrow();
-	}
-	catch(NoSuchElementException success) {}
+        assertEquals(3, k);
     }
-    
+
     /**
-     *
+     * descendingIterator.remove removes current element
      */
-    public void testGetLast_NoSuchElementException() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.getLast();
-	    shouldThrow();
-	}
-	catch(NoSuchElementException success) {}
+    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);
-	    shouldThrow();
-	}
-	catch(NullPointerException success){}
-    }
-    
-    
-    /**
-     *
+     * toString contains toStrings of elements
      */
-    public void testAddAll1_OutOfBounds() {
-	try {
-	    LinkedList l = new LinkedList(); 
-	    l.addAll(4,new LinkedList());
-	    shouldThrow();
-	}
-	catch(IndexOutOfBoundsException  success) {}
+    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);
+        }
     }
-    
-    
+
     /**
-     *
+     * peek returns element inserted with addFirst
      */
-    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) {}
+    public void testAddFirst() {
+        LinkedList q = populatedQueue(3);
+	q.addFirst(four);
+	assertEquals(four,q.peek());
     }
 
     /**
-     *
+     * peekFirst returns element inserted with push
      */
-    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){}
+    public void testPush() {
+        LinkedList q = populatedQueue(3);
+        q.pollLast();
+	q.push(four);
+	assertEquals(four,q.peekFirst());
     }
 
     /**
-     *
+     *  pop removes next element, or throws NSEE if empty
      */
-    public void testget1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.get(-1);
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success) {}	
+    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) {
+	}
     }
 
     /**
-     *
+     * OfferFirst succeeds
      */
-    public void testget2() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.get(5);
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}	
+    public void testOfferFirst() {
+        LinkedList q = new LinkedList();
+        assertTrue(q.offerFirst(new Integer(0)));
+        assertTrue(q.offerFirst(new Integer(1)));
     }
 
     /**
-     *
+     * OfferLast succeeds
      */
-    public void testset1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.set(-1,new Object());
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}	
+    public void testOfferLast() {
+        LinkedList q = new LinkedList();
+        assertTrue(q.offerLast(new Integer(0)));
+        assertTrue(q.offerLast(new Integer(1)));
     }
 
     /**
-     *
+     *  pollLast succeeds unless empty
      */
-    public void testset2() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.set(5,new Object());
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}	
+    public void testPollLast() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = SIZE-1; i >= 0; --i) {
+            assertEquals(i, ((Integer)q.pollLast()).intValue());
+        }
+	assertNull(q.pollLast());
     }
 
     /**
-     *
+     *  peekFirst returns next element, or null if empty
      */
-    public void testadd1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.add(-1,new Object());
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}	
+    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 add2() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.add(5,new Object());
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success) {}	
-    }
 
     /**
-     *
+     *  peekLast returns next element, or null if empty
      */
-    public void testremove() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.remove(-1);
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}
-    }
-    
-    /**
-     *
-     */
-    public void testremove1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.remove(5);
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}
+    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 testremove2() {
+    public void testFirstElement() {
+        LinkedList q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            assertEquals(i, ((Integer)q.getFirst()).intValue());
+            q.pollFirst();
+        }
         try {
-	    LinkedList l = new LinkedList();
-            l.remove();
+            q.getFirst();
             shouldThrow();
-	} catch(NoSuchElementException e){}	
+        }
+        catch (NoSuchElementException success) {}
     }
 
     /**
-     *
-     */
-    public void testlistIt1() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.listIterator(5);
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}
-    }
-    
-    /**
-     *
-     */
-    public void testlistIt2() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    l.listIterator(-1);
-	    shouldThrow();
-	} catch(IndexOutOfBoundsException  success){}
-    }
-    
-    /**
-     *
+     *  getLast returns next element, or throws NSEE if empty
      */
-    public void testlistIt3() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    ListIterator a = l.listIterator(0);
-	    l.removeFirst();
-	    a.next();
-	    shouldThrow();
-	} catch(ConcurrentModificationException success){}
+    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());
     }
 
     /**
-     *
+     * removeFirstOccurrence(x) removes x and returns true if present
      */
-    public void testToArray_BadArg() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Object());
-	    Object o[] = l.toArray(null);
-	    shouldThrow();
-	} catch(NullPointerException success){}
+    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 testToArray1_BadArg() {
-	try {
-	    LinkedList l = new LinkedList();
-	    l.add(new Integer(5));
-	    Object o[] = l.toArray(new String[10] );
-	    shouldThrow();
-	} catch(ArrayStoreException  success){}
+    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());
     }
 
 }