--- jsr166/src/test/tck/PriorityQueueTest.java	2003/09/20 18:20:08	1.5
+++ jsr166/src/test/tck/PriorityQueueTest.java	2009/11/21 10:29:50	1.14
@@ -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,16 +12,14 @@ import java.util.concurrent.*;
 import java.io.*;
 
 public class PriorityQueueTest extends JSR166TestCase {
-
     public static void main(String[] args) {
-	junit.textui.TestRunner.run (suite());	
+        junit.textui.TestRunner.run (suite());
     }
-
     public static Test suite() {
-	return new TestSuite(PriorityQueueTest.class);
+        return new TestSuite(PriorityQueueTest.class);
     }
 
-    static class MyReverseComparator implements Comparator { 
+    static class MyReverseComparator implements Comparator {
         public int compare(Object x, Object y) {
             int i = ((Integer)x).intValue();
             int j = ((Integer)y).intValue();
@@ -30,7 +29,6 @@ public class PriorityQueueTest extends J
         }
     }
 
-
     /**
      * Create a queue of given size containing consecutive
      * Integers 0 ... n.
@@ -38,59 +36,55 @@ public class PriorityQueueTest extends J
     private PriorityQueue populatedQueue(int n) {
         PriorityQueue q = new PriorityQueue(n);
         assertTrue(q.isEmpty());
-	for(int i = n-1; i >= 0; i-=2)
-	    assertTrue(q.offer(new Integer(i)));
-	for(int i = (n & 1); i < n; i+=2)
-	    assertTrue(q.offer(new Integer(i)));
+        for (int i = n-1; i >= 0; i-=2)
+            assertTrue(q.offer(new Integer(i)));
+        for (int i = (n & 1); i < n; i+=2)
+            assertTrue(q.offer(new Integer(i)));
         assertFalse(q.isEmpty());
-	assertEquals(n, q.size());
+        assertEquals(n, q.size());
         return q;
     }
- 
+
     /**
-     *
+     * A new queue has unbounded capacity
      */
     public void testConstructor1() {
         assertEquals(0, new PriorityQueue(SIZE).size());
     }
 
     /**
-     *
+     * Constructor throws IAE if capacity argument nonpositive
      */
     public void testConstructor2() {
         try {
             PriorityQueue q = new PriorityQueue(0);
             shouldThrow();
-        }
-        catch (IllegalArgumentException success) {}
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
-     *
+     * Initializing from null Collection throws NPE
      */
     public void testConstructor3() {
-
         try {
             PriorityQueue q = new PriorityQueue((Collection)null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Initializing from Collection of null elements throws NPE
      */
     public void testConstructor4() {
         try {
             Integer[] ints = new Integer[SIZE];
             PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Initializing from Collection with some null elements throws NPE
      */
     public void testConstructor5() {
         try {
@@ -99,45 +93,38 @@ public class PriorityQueueTest extends J
                 ints[i] = new Integer(i);
             PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * 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)
-                ints[i] = new Integer(i);
-            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = new Integer(i);
+        PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.poll());
     }
 
     /**
-     *
+     * The comparator used in constructor is used
      */
     public void testConstructor7() {
-        try {
-            MyReverseComparator cmp = new MyReverseComparator();
-            PriorityQueue q = new PriorityQueue(SIZE, cmp);
-            assertEquals(cmp, q.comparator());
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            q.addAll(Arrays.asList(ints));
-            for (int i = SIZE-1; i >= 0; --i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+        MyReverseComparator cmp = new MyReverseComparator();
+        PriorityQueue q = new PriorityQueue(SIZE, cmp);
+        assertEquals(cmp, q.comparator());
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = new Integer(i);
+        q.addAll(Arrays.asList(ints));
+        for (int i = SIZE-1; i >= 0; --i)
+            assertEquals(ints[i], q.poll());
     }
 
     /**
-     *
+     * isEmpty is true before add, false after
      */
     public void testEmpty() {
         PriorityQueue q = new PriorityQueue(2);
@@ -151,7 +138,7 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * size changes when elements added and removed
      */
     public void testSize() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -166,27 +153,38 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * offer(null) throws NPE
      */
     public void testOfferNull() {
-	try {
+        try {
             PriorityQueue q = new PriorityQueue(1);
             q.offer(null);
             shouldThrow();
-        } catch (NullPointerException success) { }   
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * add(null) throws NPE
+     */
+    public void testAddNull() {
+        try {
+            PriorityQueue q = new PriorityQueue(1);
+            q.add(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Offer of comparable element succeeds
      */
     public void testOffer() {
         PriorityQueue q = new PriorityQueue(1);
-        assertTrue(q.offer(new Integer(0)));
-        assertTrue(q.offer(new Integer(1)));
+        assertTrue(q.offer(zero));
+        assertTrue(q.offer(one));
     }
 
     /**
-     *
+     * Offer of non-Comparable throws CCE
      */
     public void testOfferNonComparable() {
         try {
@@ -195,12 +193,11 @@ public class PriorityQueueTest extends J
             q.offer(new Object());
             q.offer(new Object());
             shouldThrow();
-        }
-        catch(ClassCastException success) {}
+        } catch (ClassCastException success) {}
     }
 
     /**
-     *
+     * add of comparable succeeds
      */
     public void testAdd() {
         PriorityQueue q = new PriorityQueue(SIZE);
@@ -211,18 +208,17 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * addAll(null) throws NPE
      */
     public void testAddAll1() {
         try {
             PriorityQueue q = new PriorityQueue(1);
             q.addAll(null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
     /**
-     *
+     * addAll of a collection with null elements throws NPE
      */
     public void testAddAll2() {
         try {
@@ -230,11 +226,11 @@ public class PriorityQueueTest extends J
             Integer[] ints = new Integer[SIZE];
             q.addAll(Arrays.asList(ints));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
     /**
-     *
+     * addAll of a collection with any null elements throws NPE after
+     * possibly adding some elements
      */
     public void testAddAll3() {
         try {
@@ -244,41 +240,37 @@ public class PriorityQueueTest extends J
                 ints[i] = new Integer(i);
             q.addAll(Arrays.asList(ints));
             shouldThrow();
-        }
-        catch (NullPointerException success) {}
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *
+     * Queue contains all elements of successful addAll
      */
     public void testAddAll5() {
-        try {
-            Integer[] empty = new Integer[0];
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(SIZE-1-i);
-            PriorityQueue q = new PriorityQueue(SIZE);
-            assertFalse(q.addAll(Arrays.asList(empty)));
-            assertTrue(q.addAll(Arrays.asList(ints)));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(new Integer(i), q.poll());
-        }
-        finally {}
+        Integer[] empty = new Integer[0];
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = new Integer(SIZE-1-i);
+        PriorityQueue q = new PriorityQueue(SIZE);
+        assertFalse(q.addAll(Arrays.asList(empty)));
+        assertTrue(q.addAll(Arrays.asList(ints)));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(new Integer(i), q.poll());
     }
 
     /**
-     *
+     * poll succeeds unless empty
      */
     public void testPoll() {
         PriorityQueue q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.poll()).intValue());
         }
-	assertNull(q.poll());
+        assertNull(q.poll());
     }
 
     /**
-     *
+     * peek returns next element, or null if empty
      */
     public void testPeek() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -288,11 +280,11 @@ public class PriorityQueueTest extends J
             assertTrue(q.peek() == null ||
                        i != ((Integer)q.peek()).intValue());
         }
-	assertNull(q.peek());
+        assertNull(q.peek());
     }
 
     /**
-     *
+     * element returns next element, or throws NSEE if empty
      */
     public void testElement() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -303,12 +295,11 @@ public class PriorityQueueTest extends J
         try {
             q.element();
             shouldThrow();
-        }
-        catch (NoSuchElementException success) {}
+        } catch (NoSuchElementException success) {}
     }
 
     /**
-     *
+     * remove removes next element, or throws NSEE if empty
      */
     public void testRemove() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -318,12 +309,11 @@ public class PriorityQueueTest extends J
         try {
             q.remove();
             shouldThrow();
-        } catch (NoSuchElementException success){
-	}   
+        } catch (NoSuchElementException success) {}
     }
 
     /**
-     *
+     * remove(x) removes x and returns true if present
      */
     public void testRemoveElement() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -336,9 +326,9 @@ public class PriorityQueueTest extends J
         }
         assertTrue(q.isEmpty());
     }
-	
+
     /**
-     *
+     * contains(x) reports true when elements added but not yet removed
      */
     public void testContains() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -350,7 +340,7 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * clear removes all elements
      */
     public void testClear() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -364,7 +354,7 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * containsAll(c) is true when c contains a subset of elements
      */
     public void testContainsAll() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -378,7 +368,7 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * retainAll(c) retains only those elements of c and reports true if changed
      */
     public void testRetainAll() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -397,7 +387,7 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * removeAll(c) removes only those elements of c and reports true if changed
      */
     public void testRemoveAll() {
         for (int i = 1; i < SIZE; ++i) {
@@ -413,36 +403,36 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * toArray contains all elements
      */
     public void testToArray() {
         PriorityQueue q = populatedQueue(SIZE);
-	Object[] o = q.toArray();
+        Object[] o = q.toArray();
         Arrays.sort(o);
-	for(int i = 0; i < o.length; i++)
-	    assertEquals(o[i], q.poll());
+        for (int i = 0; i < o.length; i++)
+            assertEquals(o[i], q.poll());
     }
 
     /**
-     *
+     * toArray(a) contains all elements
      */
     public void testToArray2() {
         PriorityQueue q = populatedQueue(SIZE);
-	Integer[] ints = new Integer[SIZE];
-	ints = (Integer[])q.toArray(ints);
+        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());
     }
-    
+
     /**
-     *
+     * iterator iterates through all elements
      */
     public void testIterator() {
         PriorityQueue q = populatedQueue(SIZE);
         int i = 0;
-	Iterator it = q.iterator();
-        while(it.hasNext()) {
+        Iterator it = q.iterator();
+        while (it.hasNext()) {
             assertTrue(q.contains(it.next()));
             ++i;
         }
@@ -450,7 +440,7 @@ public class PriorityQueueTest extends J
     }
 
     /**
-     *
+     * iterator.remove removes current element
      */
     public void testIteratorRemove () {
         final PriorityQueue q = new PriorityQueue(3);
@@ -470,7 +460,7 @@ public class PriorityQueueTest extends J
 
 
     /**
-     *
+     * toString contains toStrings of elements
      */
     public void testToString() {
         PriorityQueue q = populatedQueue(SIZE);
@@ -478,27 +468,23 @@ public class PriorityQueueTest extends J
         for (int i = 0; i < SIZE; ++i) {
             assertTrue(s.indexOf(String.valueOf(i)) >= 0);
         }
-    }        
+    }
 
     /**
-     *
+     * A deserialized serialized queue has same elements
      */
-    public void testSerialization() {
+    public void testSerialization() throws Exception {
         PriorityQueue q = populatedQueue(SIZE);
-        try {
-            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
-            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
-            out.writeObject(q);
-            out.close();
-
-            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
-            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
-            PriorityQueue r = (PriorityQueue)in.readObject();
-            assertEquals(q.size(), r.size());
-            while (!q.isEmpty()) 
-                assertEquals(q.remove(), r.remove());
-        } catch(Exception e){
-            unexpectedException();
-        }
+        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+        out.writeObject(q);
+        out.close();
+
+        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+        PriorityQueue r = (PriorityQueue)in.readObject();
+        assertEquals(q.size(), r.size());
+        while (!q.isEmpty())
+            assertEquals(q.remove(), r.remove());
     }
 }