--- jsr166/src/test/tck/DelayQueueTest.java	2003/09/25 11:02:41	1.5
+++ jsr166/src/test/tck/DelayQueueTest.java	2003/10/05 23:00:40	1.6
@@ -232,6 +232,17 @@ public class DelayQueueTest extends JSR1
     }
 
     /**
+     * add(null) throws NPE
+     */
+    public void testAddNull() {
+	try {
+            DelayQueue q = new DelayQueue();
+            q.add(null);
+            shouldThrow();
+        } catch (NullPointerException success) { }   
+    }
+
+    /**
      * offer non-null succeeds
      */
     public void testOffer() {
@@ -262,6 +273,20 @@ public class DelayQueueTest extends JSR1
         }
         catch (NullPointerException success) {}
     }
+
+
+    /**
+     * addAll(this) throws IAE
+     */
+    public void testAddAllSelf() {
+        try {
+            DelayQueue q = populatedQueue(SIZE);
+            q.addAll(q);
+            shouldThrow();
+        }
+        catch (IllegalArgumentException success) {}
+    }
+
     /**
      * addAll of a collection with null elements throws NPE
      */
@@ -724,6 +749,29 @@ public class DelayQueueTest extends JSR1
 	    unexpectedException();
 	}    
     }
+
+
+    /**
+     * toArray(null) throws NPE
+     */
+    public void testToArray_BadArg() {
+	try {
+            DelayQueue q = populatedQueue(SIZE);
+	    Object o[] = q.toArray(null);
+	    shouldThrow();
+	} catch(NullPointerException success){}
+    }
+
+    /**
+     * toArray with incompatable array type throws CCE
+     */
+    public void testToArray1_BadArg() {
+	try {
+            DelayQueue q = populatedQueue(SIZE);
+	    Object o[] = q.toArray(new String[10] );
+	    shouldThrow();
+	} catch(ArrayStoreException  success){}
+    }
     
     /**
      * iterator iterates through all elements
@@ -832,4 +880,101 @@ public class DelayQueueTest extends JSR1
         }
     }
 
+
+    /**
+     * drainTo(null) throws NPE
+     */ 
+    public void testDrainToNull() {
+        DelayQueue q = populatedQueue(SIZE);
+        try {
+            q.drainTo(null);
+            shouldThrow();
+        } catch(NullPointerException success) {
+        }
+    }
+
+    /**
+     * drainTo(this) throws IAE
+     */ 
+    public void testDrainToSelf() {
+        DelayQueue q = populatedQueue(SIZE);
+        try {
+            q.drainTo(q);
+            shouldThrow();
+        } catch(IllegalArgumentException success) {
+        }
+    }
+
+    /**
+     * drainTo(c) empties queue into another collection c
+     */ 
+    public void testDrainTo() {
+        DelayQueue q = populatedQueue(SIZE);
+        ArrayList l = new ArrayList();
+        q.drainTo(l);
+        assertEquals(q.size(), 0);
+        assertEquals(l.size(), SIZE);
+    }
+
+    /**
+     * drainTo empties queue
+     */ 
+    public void testDrainToWithActivePut() {
+        final DelayQueue q = populatedQueue(SIZE);
+        Thread t = new Thread(new Runnable() {
+                public void run() {
+                    q.put(new PDelay(SIZE+1));
+                }
+            });
+        try {
+            t.start();
+            ArrayList l = new ArrayList();
+            q.drainTo(l);
+            assertTrue(l.size() >= SIZE);
+            t.join();
+            assertTrue(q.size() + l.size() == SIZE+1);
+        } catch(Exception e){
+            unexpectedException();
+        }
+    }
+
+    /**
+     * drainTo(null, n) throws NPE
+     */ 
+    public void testDrainToNullN() {
+        DelayQueue q = populatedQueue(SIZE);
+        try {
+            q.drainTo(null, 0);
+            shouldThrow();
+        } catch(NullPointerException success) {
+        }
+    }
+
+    /**
+     * drainTo(this, n) throws IAE
+     */ 
+    public void testDrainToSelfN() {
+        DelayQueue q = populatedQueue(SIZE);
+        try {
+            q.drainTo(q, 0);
+            shouldThrow();
+        } catch(IllegalArgumentException success) {
+        }
+    }
+
+    /**
+     * drainTo(c, n) empties first max {n, size} elements of queue into c
+     */ 
+    public void testDrainToN() {
+        for (int i = 0; i < SIZE + 2; ++i) {
+            DelayQueue q = populatedQueue(SIZE);
+            ArrayList l = new ArrayList();
+            q.drainTo(l, i);
+            int k = (i < SIZE)? i : SIZE;
+            assertEquals(q.size(), SIZE-k);
+            assertEquals(l.size(), k);
+        }
+    }
+
+
 }