--- jsr166/src/test/tck/PriorityBlockingQueueTest.java	2003/09/07 20:39:11	1.2
+++ jsr166/src/test/tck/PriorityBlockingQueueTest.java	2003/09/20 18:20:08	1.5
@@ -10,14 +10,7 @@ import java.util.*;
 import java.util.concurrent.*;
 import java.io.*;
 
-public class PriorityBlockingQueueTest extends TestCase {
-
-    private static final int N = 10;
-    private static final long SHORT_DELAY_MS = 100; 
-    private static final long MEDIUM_DELAY_MS = 1000;
-    private static final long LONG_DELAY_MS = 10000; 
-    private static final int NOCAP = Integer.MAX_VALUE;
-
+public class PriorityBlockingQueueTest extends JSR166TestCase {
     public static void main(String[] args) {
 	junit.textui.TestRunner.run (suite());	
     }
@@ -26,6 +19,9 @@ public class PriorityBlockingQueueTest e
 	return new TestSuite(PriorityBlockingQueueTest.class);
     }
 
+    private static final int NOCAP = Integer.MAX_VALUE;
+
+    /** Sample Comparator */
     static class MyReverseComparator implements Comparator { 
         public int compare(Object x, Object y) {
             int i = ((Integer)x).intValue();
@@ -41,7 +37,7 @@ public class PriorityBlockingQueueTest e
      * Create a queue of given size containing consecutive
      * Integers 0 ... n.
      */
-    private PriorityBlockingQueue fullQueue(int n) {
+    private PriorityBlockingQueue populatedQueue(int n) {
         PriorityBlockingQueue q = new PriorityBlockingQueue(n);
         assertTrue(q.isEmpty());
 	for(int i = n-1; i >= 0; i-=2)
@@ -54,72 +50,98 @@ public class PriorityBlockingQueueTest e
         return q;
     }
  
-    public void testConstructor1(){
-        assertEquals(NOCAP, new PriorityBlockingQueue(N).remainingCapacity());
+    /**
+     *
+     */
+    public void testConstructor1() {
+        assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
     }
 
-    public void testConstructor2(){
+    /**
+     *
+     */
+    public void testConstructor2() {
         try {
             PriorityBlockingQueue q = new PriorityBlockingQueue(0);
-            fail("Cannot make zero-sized");
+            shouldThrow();
         }
         catch (IllegalArgumentException success) {}
     }
 
-    public void testConstructor3(){
+    /**
+     *
+     */
+    public void testConstructor3() {
 
         try {
             PriorityBlockingQueue q = new PriorityBlockingQueue(null);
-            fail("Cannot make from null collection");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
 
-    public void testConstructor4(){
+    /**
+     *
+     */
+    public void testConstructor4() {
         try {
-            Integer[] ints = new Integer[N];
+            Integer[] ints = new Integer[SIZE];
             PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
-            fail("Cannot make with null elements");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
 
-    public void testConstructor5(){
+    /**
+     *
+     */
+    public void testConstructor5() {
         try {
-            Integer[] ints = new Integer[N];
-            for (int i = 0; i < N-1; ++i)
+            Integer[] ints = new Integer[SIZE];
+            for (int i = 0; i < SIZE-1; ++i)
                 ints[i] = new Integer(i);
             PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
-            fail("Cannot make with null elements");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
 
-    public void testConstructor6(){
+    /**
+     *
+     */
+    public void testConstructor6() {
         try {
-            Integer[] ints = new Integer[N];
-            for (int i = 0; i < N; ++i)
+            Integer[] ints = new Integer[SIZE];
+            for (int i = 0; i < SIZE; ++i)
                 ints[i] = new Integer(i);
             PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
-            for (int i = 0; i < N; ++i)
+            for (int i = 0; i < SIZE; ++i)
                 assertEquals(ints[i], q.poll());
         }
         finally {}
     }
 
-    public void testConstructor7(){
+    /**
+     *
+     */
+    public void testConstructor7() {
         try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(N, new MyReverseComparator());
-            Integer[] ints = new Integer[N];
-            for (int i = 0; i < N; ++i)
+            MyReverseComparator cmp = new MyReverseComparator();
+            PriorityBlockingQueue q = new PriorityBlockingQueue(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 = N-1; i >= 0; --i)
+            for (int i = SIZE-1; i >= 0; --i)
                 assertEquals(ints[i], q.poll());
         }
         finally {}
     }
 
+    /**
+     *
+     */
     public void testEmpty() {
         PriorityBlockingQueue q = new PriorityBlockingQueue(2);
         assertTrue(q.isEmpty());
@@ -132,125 +154,161 @@ public class PriorityBlockingQueueTest e
         assertTrue(q.isEmpty());
     }
 
-    public void testRemainingCapacity(){
-        PriorityBlockingQueue q = fullQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testRemainingCapacity() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             assertEquals(NOCAP, q.remainingCapacity());
-            assertEquals(N-i, q.size());
+            assertEquals(SIZE-i, q.size());
             q.remove();
         }
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < SIZE; ++i) {
             assertEquals(NOCAP, q.remainingCapacity());
             assertEquals(i, q.size());
             q.add(new Integer(i));
         }
     }
 
-    public void testOfferNull(){
+    /**
+     *
+     */
+    public void testOfferNull() {
 	try {
             PriorityBlockingQueue q = new PriorityBlockingQueue(1);
             q.offer(null);
-            fail("should throw NPE");
+            shouldThrow();
         } catch (NullPointerException success) { }   
     }
 
+    /**
+     *
+     */
     public void testOffer() {
         PriorityBlockingQueue q = new PriorityBlockingQueue(1);
         assertTrue(q.offer(new Integer(0)));
         assertTrue(q.offer(new Integer(1)));
     }
 
+    /**
+     *
+     */
     public void testOfferNonComparable() {
         try {
             PriorityBlockingQueue q = new PriorityBlockingQueue(1);
             q.offer(new Object());
             q.offer(new Object());
             q.offer(new Object());
-            fail("should throw CCE");
+            shouldThrow();
         }
         catch(ClassCastException success) {}
     }
 
-    public void testAdd(){
-        PriorityBlockingQueue q = new PriorityBlockingQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testAdd() {
+        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, q.size());
             assertTrue(q.add(new Integer(i)));
         }
     }
 
-    public void testAddAll1(){
+    /**
+     *
+     */
+    public void testAddAll1() {
         try {
             PriorityBlockingQueue q = new PriorityBlockingQueue(1);
             q.addAll(null);
-            fail("Cannot add null collection");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
-    public void testAddAll2(){
+    /**
+     *
+     */
+    public void testAddAll2() {
         try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(N);
-            Integer[] ints = new Integer[N];
+            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+            Integer[] ints = new Integer[SIZE];
             q.addAll(Arrays.asList(ints));
-            fail("Cannot add null elements");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
-    public void testAddAll3(){
+    /**
+     *
+     */
+    public void testAddAll3() {
         try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(N);
-            Integer[] ints = new Integer[N];
-            for (int i = 0; i < N-1; ++i)
+            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+            Integer[] ints = new Integer[SIZE];
+            for (int i = 0; i < SIZE-1; ++i)
                 ints[i] = new Integer(i);
             q.addAll(Arrays.asList(ints));
-            fail("Cannot add null elements");
+            shouldThrow();
         }
         catch (NullPointerException success) {}
     }
 
-    public void testAddAll5(){
+    /**
+     *
+     */
+    public void testAddAll5() {
         try {
             Integer[] empty = new Integer[0];
-            Integer[] ints = new Integer[N];
-            for (int i = N-1; i >= 0; --i)
+            Integer[] ints = new Integer[SIZE];
+            for (int i = SIZE-1; i >= 0; --i)
                 ints[i] = new Integer(i);
-            PriorityBlockingQueue q = new PriorityBlockingQueue(N);
+            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
             assertFalse(q.addAll(Arrays.asList(empty)));
             assertTrue(q.addAll(Arrays.asList(ints)));
-            for (int i = 0; i < N; ++i)
+            for (int i = 0; i < SIZE; ++i)
                 assertEquals(ints[i], q.poll());
         }
         finally {}
     }
 
+    /**
+     *
+     */
      public void testPutNull() {
 	try {
-            PriorityBlockingQueue q = new PriorityBlockingQueue(N);
+            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
             q.put(null);
-            fail("put should throw NPE");
+            shouldThrow();
         } 
         catch (NullPointerException success){
 	}   
      }
 
+    /**
+     *
+     */
      public void testPut() {
          try {
-             PriorityBlockingQueue q = new PriorityBlockingQueue(N);
-             for (int i = 0; i < N; ++i) {
+             PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
+             for (int i = 0; i < SIZE; ++i) {
                  Integer I = new Integer(i);
                  q.put(I);
                  assertTrue(q.contains(I));
              }
-             assertEquals(N, q.size());
+             assertEquals(SIZE, q.size());
          }
          finally {
         }
     }
 
+    /**
+     *
+     */
     public void testPutWithTake() {
         final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
         Thread t = new Thread(new Runnable() {
-                public void run(){
+                public void run() {
                     int added = 0;
                     try {
                         q.put(new Integer(0));
@@ -261,7 +319,7 @@ public class PriorityBlockingQueueTest e
                         ++added;
                         q.put(new Integer(0));
                         ++added;
-                        assertTrue(added == 4);
+                        threadAssertTrue(added == 4);
                     } finally {
                     }
                 }
@@ -273,51 +331,60 @@ public class PriorityBlockingQueueTest e
             t.interrupt();
             t.join();
         } catch (Exception e){
-            fail("Unexpected exception");
+            unexpectedException();
         }
     }
 
+    /**
+     *
+     */
     public void testTimedOffer() {
         final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
         Thread t = new Thread(new Runnable() {
-                public void run(){
+                public void run() {
                     try {
                         q.put(new Integer(0));
                         q.put(new Integer(0));
-                        assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
-                        assertTrue(q.offer(new Integer(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
+                        threadAssertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+                        threadAssertTrue(q.offer(new Integer(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
                     } finally { }
                 }
             });
         
         try {
             t.start();
-            Thread.sleep(SHORT_DELAY_MS);
+            Thread.sleep(SMALL_DELAY_MS);
             t.interrupt();
             t.join();
         } catch (Exception e){
-            fail("Unexpected exception");
+            unexpectedException();
         }
     }
 
-    public void testTake(){
+    /**
+     *
+     */
+    public void testTake() {
 	try {
-            PriorityBlockingQueue q = fullQueue(N);
-            for (int i = 0; i < N; ++i) {
+            PriorityBlockingQueue q = populatedQueue(SIZE);
+            for (int i = 0; i < SIZE; ++i) {
                 assertEquals(i, ((Integer)q.take()).intValue());
             }
         } catch (InterruptedException e){
-	    fail("Unexpected exception");
+	    unexpectedException();
 	}   
     }
 
+    /**
+     *
+     */
     public void testTakeFromEmpty() {
         final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
         Thread t = new Thread(new Runnable() {
-                public void run(){
+                public void run() {
                     try {
                         q.take();
-			fail("Should block");
+			threadShouldThrow();
                     } catch (InterruptedException success){ }                
                 }
             });
@@ -327,20 +394,23 @@ public class PriorityBlockingQueueTest e
             t.interrupt();
             t.join();
         } catch (Exception e){
-            fail("Unexpected exception");
+            unexpectedException();
         }
     }
 
-    public void testBlockingTake(){
+    /**
+     *
+     */
+    public void testBlockingTake() {
         Thread t = new Thread(new Runnable() {
                 public void run() {
                     try {
-                        PriorityBlockingQueue q = fullQueue(N);
-                        for (int i = 0; i < N; ++i) {
-                            assertEquals(i, ((Integer)q.take()).intValue());
+                        PriorityBlockingQueue q = populatedQueue(SIZE);
+                        for (int i = 0; i < SIZE; ++i) {
+                            threadAssertEquals(i, ((Integer)q.take()).intValue());
                         }
                         q.take();
-                        fail("take should block");
+                        threadShouldThrow();
                     } catch (InterruptedException success){
                     }   
                 }});
@@ -351,52 +421,64 @@ public class PriorityBlockingQueueTest e
            t.join();
         }
         catch (InterruptedException ie) {
-	    fail("Unexpected exception");
+	    unexpectedException();
         }
     }
 
 
-    public void testPoll(){
-        PriorityBlockingQueue q = fullQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testPoll() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.poll()).intValue());
         }
 	assertNull(q.poll());
     }
 
+    /**
+     *
+     */
     public void testTimedPoll0() {
         try {
-            PriorityBlockingQueue q = fullQueue(N);
-            for (int i = 0; i < N; ++i) {
+            PriorityBlockingQueue q = populatedQueue(SIZE);
+            for (int i = 0; i < SIZE; ++i) {
                 assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
             }
             assertNull(q.poll(0, TimeUnit.MILLISECONDS));
         } catch (InterruptedException e){
-	    fail("Unexpected exception");
+	    unexpectedException();
 	}   
     }
 
+    /**
+     *
+     */
     public void testTimedPoll() {
         try {
-            PriorityBlockingQueue q = fullQueue(N);
-            for (int i = 0; i < N; ++i) {
+            PriorityBlockingQueue q = populatedQueue(SIZE);
+            for (int i = 0; i < SIZE; ++i) {
                 assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
             }
             assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
         } catch (InterruptedException e){
-	    fail("Unexpected exception");
+	    unexpectedException();
 	}   
     }
 
-    public void testInterruptedTimedPoll(){
+    /**
+     *
+     */
+    public void testInterruptedTimedPoll() {
         Thread t = new Thread(new Runnable() {
                 public void run() {
                     try {
-                        PriorityBlockingQueue q = fullQueue(N);
-                        for (int i = 0; i < N; ++i) {
-                            assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
+                        PriorityBlockingQueue q = populatedQueue(SIZE);
+                        for (int i = 0; i < SIZE; ++i) {
+                            threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
                         }
-                        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+                        threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                     } catch (InterruptedException success){
                     }   
                 }});
@@ -407,37 +489,43 @@ public class PriorityBlockingQueueTest e
            t.join();
         }
         catch (InterruptedException ie) {
-	    fail("Unexpected exception");
+	    unexpectedException();
         }
     }
 
-    public void testTimedPollWithOffer(){
+    /**
+     *
+     */
+    public void testTimedPollWithOffer() {
         final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
         Thread t = new Thread(new Runnable() {
-                public void run(){
+                public void run() {
                     try {
-                        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
+                        threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
-			fail("Should block");
+			threadShouldThrow();
                     } catch (InterruptedException success) { }                
                 }
             });
         try {
             t.start();
-            Thread.sleep(SHORT_DELAY_MS * 2);
+            Thread.sleep(SMALL_DELAY_MS);
             assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
             t.interrupt();
             t.join();
         } catch (Exception e){
-            fail("Unexpected exception");
+            unexpectedException();
         }
     }  
 
 
-    public void testPeek(){
-        PriorityBlockingQueue q = fullQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testPeek() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.peek()).intValue());
             q.poll();
             assertTrue(q.peek() == null ||
@@ -446,54 +534,69 @@ public class PriorityBlockingQueueTest e
 	assertNull(q.peek());
     }
 
-    public void testElement(){
-        PriorityBlockingQueue q = fullQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testElement() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             assertEquals(i, ((Integer)q.element()).intValue());
             q.poll();
         }
         try {
             q.element();
-            fail("no such element");
+            shouldThrow();
         }
         catch (NoSuchElementException success) {}
     }
 
-    public void testRemove(){
-        PriorityBlockingQueue q = fullQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testRemove() {
+        PriorityBlockingQueue 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(){
-        PriorityBlockingQueue q = fullQueue(N);
-        for (int i = 1; i < N; i+=2) {
+    /**
+     *
+     */
+    public void testRemoveElement() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        for (int i = 1; i < SIZE; i+=2) {
             assertTrue(q.remove(new Integer(i)));
         }
-        for (int i = 0; i < N; i+=2) {
+        for (int i = 0; i < SIZE; i+=2) {
             assertTrue(q.remove(new Integer(i)));
             assertFalse(q.remove(new Integer(i+1)));
         }
         assertTrue(q.isEmpty());
     }
 	
-    public void testContains(){
-        PriorityBlockingQueue q = fullQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testContains() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.contains(new Integer(i)));
             q.poll();
             assertFalse(q.contains(new Integer(i)));
         }
     }
 
-    public void testClear(){
-        PriorityBlockingQueue q = fullQueue(N);
+    /**
+     *
+     */
+    public void testClear() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
         q.clear();
         assertTrue(q.isEmpty());
         assertEquals(0, q.size());
@@ -504,10 +607,13 @@ public class PriorityBlockingQueueTest e
         assertTrue(q.isEmpty());
     }
 
-    public void testContainsAll(){
-        PriorityBlockingQueue q = fullQueue(N);
-        PriorityBlockingQueue p = new PriorityBlockingQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testContainsAll() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue p = new PriorityBlockingQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             assertTrue(q.containsAll(p));
             assertFalse(p.containsAll(q));
             p.add(new Integer(i));
@@ -515,10 +621,13 @@ public class PriorityBlockingQueueTest e
         assertTrue(p.containsAll(q));
     }
 
-    public void testRetainAll(){
-        PriorityBlockingQueue q = fullQueue(N);
-        PriorityBlockingQueue p = fullQueue(N);
-        for (int i = 0; i < N; ++i) {
+    /**
+     *
+     */
+    public void testRetainAll() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+        PriorityBlockingQueue p = populatedQueue(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
             boolean changed = q.retainAll(p);
             if (i == 0)
                 assertFalse(changed);
@@ -526,17 +635,20 @@ public class PriorityBlockingQueueTest e
                 assertTrue(changed);
 
             assertTrue(q.containsAll(p));
-            assertEquals(N-i, q.size());
+            assertEquals(SIZE-i, q.size());
             p.remove();
         }
     }
 
-    public void testRemoveAll(){
-        for (int i = 1; i < N; ++i) {
-            PriorityBlockingQueue q = fullQueue(N);
-            PriorityBlockingQueue p = fullQueue(i);
+    /**
+     *
+     */
+    public void testRemoveAll() {
+        for (int i = 1; i < SIZE; ++i) {
+            PriorityBlockingQueue q = populatedQueue(SIZE);
+            PriorityBlockingQueue p = populatedQueue(i);
             assertTrue(q.removeAll(p));
-            assertEquals(N-i, q.size());
+            assertEquals(SIZE-i, q.size());
             for (int j = 0; j < i; ++j) {
                 Integer I = (Integer)(p.remove());
                 assertFalse(q.contains(I));
@@ -544,46 +656,56 @@ public class PriorityBlockingQueueTest e
         }
     }
 
-    public void testToArray(){
-        PriorityBlockingQueue q = fullQueue(N);
+    /**
+     *
+     */
+    public void testToArray() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
 	Object[] o = q.toArray();
         Arrays.sort(o);
 	try {
 	for(int i = 0; i < o.length; i++)
 	    assertEquals(o[i], q.take());
 	} catch (InterruptedException e){
-	    fail("Unexpected exception");
+	    unexpectedException();
 	}    
     }
 
-    public void testToArray2(){
-        PriorityBlockingQueue q = fullQueue(N);
-	Integer[] ints = new Integer[N];
+    /**
+     *
+     */
+    public void testToArray2() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
+	Integer[] ints = new Integer[SIZE];
 	ints = (Integer[])q.toArray(ints);
         Arrays.sort(ints);
 	try {
 	    for(int i = 0; i < ints.length; i++)
 		assertEquals(ints[i], q.take());
 	} catch (InterruptedException e){
-	    fail("Unexpected exception");
+	    unexpectedException();
 	}    
     }
     
-    public void testIterator(){
-        PriorityBlockingQueue q = fullQueue(N);
+    /**
+     *
+     */
+    public void testIterator() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
         int i = 0;
 	Iterator it = q.iterator();
         while(it.hasNext()) {
             assertTrue(q.contains(it.next()));
             ++i;
         }
-        assertEquals(i, N);
+        assertEquals(i, SIZE);
     }
 
+    /**
+     *
+     */
     public void testIteratorRemove () {
-
         final PriorityBlockingQueue q = new PriorityBlockingQueue(3);
-
         q.add(new Integer(2));
         q.add(new Integer(1));
         q.add(new Integer(3));
@@ -599,14 +721,20 @@ public class PriorityBlockingQueueTest e
     }
 
 
-    public void testToString(){
-        PriorityBlockingQueue q = fullQueue(N);
+    /**
+     *
+     */
+    public void testToString() {
+        PriorityBlockingQueue q = populatedQueue(SIZE);
         String s = q.toString();
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < SIZE; ++i) {
             assertTrue(s.indexOf(String.valueOf(i)) >= 0);
         }
     }        
 
+    /**
+     *
+     */
     public void testPollInExecutor() {
 
         final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
@@ -615,13 +743,13 @@ public class PriorityBlockingQueueTest e
 
         executor.execute(new Runnable() {
             public void run() {
-                assertNull("poll should fail", q.poll());
+                threadAssertNull(q.poll());
                 try {
-                    assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
-                    assertTrue(q.isEmpty());
+                    threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
+                    threadAssertTrue(q.isEmpty());
                 }
                 catch (InterruptedException e) {
-                    fail("should not be interrupted");
+                    threadUnexpectedException();
                 }
             }
         });
@@ -629,21 +757,24 @@ public class PriorityBlockingQueueTest e
         executor.execute(new Runnable() {
             public void run() {
                 try {
-                    Thread.sleep(MEDIUM_DELAY_MS);
+                    Thread.sleep(SMALL_DELAY_MS);
                     q.put(new Integer(1));
                 }
                 catch (InterruptedException e) {
-                    fail("should not be interrupted");
+                    threadUnexpectedException();
                 }
             }
         });
         
-        executor.shutdown();
+        joinPool(executor);
 
     }
 
+    /**
+     *
+     */
     public void testSerialization() {
-        PriorityBlockingQueue q = fullQueue(N);
+        PriorityBlockingQueue q = populatedQueue(SIZE);
         try {
             ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
             ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
@@ -657,7 +788,7 @@ public class PriorityBlockingQueueTest e
             while (!q.isEmpty()) 
                 assertEquals(q.remove(), r.remove());
         } catch(Exception e){
-            fail("unexpected exception");
+            unexpectedException();
         }
     }