--- jsr166/src/test/tck/LinkedListTest.java	2009/11/21 10:25:05	1.15
+++ jsr166/src/test/tck/LinkedListTest.java	2010/11/03 07:54:52	1.21
@@ -12,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() {
@@ -56,7 +56,7 @@ public class LinkedListTest extends JSR1
     public void testConstructor6() {
         Integer[] ints = new Integer[SIZE];
         for (int i = 0; i < SIZE; ++i)
-            ints[i] = new Integer(i);
+            ints[i] = i;
         LinkedList q = new LinkedList(Arrays.asList(ints));
         for (int i = 0; i < SIZE; ++i)
             assertEquals(ints[i], q.poll());
@@ -137,7 +137,7 @@ public class LinkedListTest extends JSR1
         Integer[] empty = new Integer[0];
         Integer[] ints = new Integer[SIZE];
         for (int i = 0; i < SIZE; ++i)
-            ints[i] = new Integer(i);
+            ints[i] = i;
         LinkedList q = new LinkedList();
         assertFalse(q.addAll(Arrays.asList(empty)));
         assertTrue(q.addAll(Arrays.asList(ints)));
@@ -174,26 +174,26 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  poll succeeds unless empty
+     * 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());
     }
 
     /**
-     *  peek returns next element, or null if empty
+     * 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());
     }
@@ -204,8 +204,8 @@ public class LinkedListTest extends JSR1
     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();
@@ -214,12 +214,12 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  remove removes next element, or throws NSEE if empty
+     * 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();
@@ -262,7 +262,7 @@ public class LinkedListTest extends JSR1
         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());
@@ -277,7 +277,7 @@ public class LinkedListTest extends JSR1
         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));
     }
@@ -318,7 +318,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  toArray contains all elements
+     * toArray contains all elements
      */
     public void testToArray() {
         LinkedList q = populatedQueue(SIZE);
@@ -329,7 +329,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  toArray(a) contains all elements
+     * toArray(a) contains all elements
      */
     public void testToArray2() {
         LinkedList q = populatedQueue(SIZE);
@@ -344,28 +344,28 @@ public class LinkedListTest extends JSR1
      * toArray(null) throws NPE
      */
     public void testToArray_BadArg() {
+        LinkedList l = new LinkedList();
+        l.add(new Object());
         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
+     * toArray(incompatible array type) throws ArrayStoreException
      */
     public void testToArray1_BadArg() {
+        LinkedList l = new LinkedList();
+        l.add(new Integer(5));
         try {
-            LinkedList l = new LinkedList();
-            l.add(new Integer(5));
-            Object o[] = l.toArray(new String[10] );
+            l.toArray(new String[10]);
             shouldThrow();
         } catch (ArrayStoreException success) {}
     }
 
     /**
-     *  iterator iterates through all elements
+     * iterator iterates through all elements
      */
     public void testIterator() {
         LinkedList q = populatedQueue(SIZE);
@@ -379,7 +379,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  iterator ordering is FIFO
+     * iterator ordering is FIFO
      */
     public void testIteratorOrdering() {
         final LinkedList q = new LinkedList();
@@ -388,8 +388,7 @@ public class LinkedListTest extends JSR1
         q.add(new Integer(3));
         int k = 0;
         for (Iterator it = q.iterator(); it.hasNext();) {
-            int i = ((Integer)(it.next())).intValue();
-            assertEquals(++k, i);
+            assertEquals(++k, it.next());
         }
 
         assertEquals(3, k);
@@ -398,22 +397,22 @@ public class LinkedListTest extends JSR1
     /**
      * iterator.remove removes current element
      */
-    public void testIteratorRemove () {
+    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(it.next(), 1);
         it.remove();
         it = q.iterator();
-        assertEquals(it.next(), new Integer(2));
-        assertEquals(it.next(), new Integer(3));
+        assertEquals(it.next(), 2);
+        assertEquals(it.next(), 3);
         assertFalse(it.hasNext());
     }
 
     /**
-     *  Descending iterator iterates through all elements
+     * Descending iterator iterates through all elements
      */
     public void testDescendingIterator() {
         LinkedList q = populatedQueue(SIZE);
@@ -432,7 +431,7 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  Descending iterator ordering is reverse FIFO
+     * Descending iterator ordering is reverse FIFO
      */
     public void testDescendingIteratorOrdering() {
         final LinkedList q = new LinkedList();
@@ -441,8 +440,7 @@ public class LinkedListTest extends JSR1
         q.add(new Integer(1));
         int k = 0;
         for (Iterator it = q.descendingIterator(); it.hasNext();) {
-            int i = ((Integer)(it.next())).intValue();
-            assertEquals(++k, i);
+            assertEquals(++k, it.next());
         }
 
         assertEquals(3, k);
@@ -451,17 +449,17 @@ public class LinkedListTest extends JSR1
     /**
      * descendingIterator.remove removes current element
      */
-    public void testDescendingIteratorRemove () {
+    public void testDescendingIteratorRemove() {
         final LinkedList q = new LinkedList();
-        q.add(new Integer(3));
-        q.add(new Integer(2));
-        q.add(new Integer(1));
+        q.add(three);
+        q.add(two);
+        q.add(one);
         Iterator it = q.descendingIterator();
         it.next();
         it.remove();
         it = q.descendingIterator();
-        assertEquals(it.next(), new Integer(2));
-        assertEquals(it.next(), new Integer(3));
+        assertSame(it.next(), two);
+        assertSame(it.next(), three);
         assertFalse(it.hasNext());
     }
 
@@ -483,7 +481,7 @@ public class LinkedListTest extends JSR1
     public void testAddFirst() {
         LinkedList q = populatedQueue(3);
         q.addFirst(four);
-        assertEquals(four,q.peek());
+        assertSame(four, q.peek());
     }
 
     /**
@@ -491,18 +489,17 @@ public class LinkedListTest extends JSR1
      */
     public void testPush() {
         LinkedList q = populatedQueue(3);
-        q.pollLast();
         q.push(four);
-        assertEquals(four,q.peekFirst());
+        assertSame(four, q.peekFirst());
     }
 
     /**
-     *  pop removes next element, or throws NSEE if empty
+     * 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());
+            assertEquals(i, q.pop());
         }
         try {
             q.pop();
@@ -529,41 +526,41 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  pollLast succeeds unless empty
+     * 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());
+            assertEquals(i, q.pollLast());
         }
         assertNull(q.pollLast());
     }
 
     /**
-     *  peekFirst returns next element, or null if empty
+     * 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();
+            assertEquals(i, q.peekFirst());
+            assertEquals(i, q.pollFirst());
             assertTrue(q.peekFirst() == null ||
-                       i != ((Integer)q.peekFirst()).intValue());
+                       !q.peekFirst().equals(i));
         }
         assertNull(q.peekFirst());
     }
 
 
     /**
-     *  peekLast returns next element, or null if empty
+     * 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();
+            assertEquals(i, q.peekLast());
+            assertEquals(i, q.pollLast());
             assertTrue(q.peekLast() == null ||
-                       i != ((Integer)q.peekLast()).intValue());
+                       !q.peekLast().equals(i));
         }
         assertNull(q.peekLast());
     }
@@ -571,8 +568,8 @@ public class LinkedListTest extends JSR1
     public void testFirstElement() {
         LinkedList q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
-            assertEquals(i, ((Integer)q.getFirst()).intValue());
-            q.pollFirst();
+            assertEquals(i, q.getFirst());
+            assertEquals(i, q.pollFirst());
         }
         try {
             q.getFirst();
@@ -581,13 +578,13 @@ public class LinkedListTest extends JSR1
     }
 
     /**
-     *  getLast returns next element, or throws NSEE if empty
+     * 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();
+            assertEquals(i, q.getLast());
+            assertEquals(i, q.pollLast());
         }
         try {
             q.getLast();