Home | History | Annotate | Download | only in jsr166
      1 /*
      2  * Written by Doug Lea with assistance from members of JCP JSR-166
      3  * Expert Group and released to the public domain, as explained at
      4  * http://creativecommons.org/publicdomain/zero/1.0/
      5  * Other contributors include Andrew Wright, Jeffrey Hayes,
      6  * Pat Fisher, Mike Judd.
      7  */
      8 
      9 package jsr166;
     10 
     11 import static java.util.concurrent.TimeUnit.MILLISECONDS;
     12 
     13 import java.util.ArrayList;
     14 import java.util.Arrays;
     15 import java.util.Collection;
     16 import java.util.Iterator;
     17 import java.util.NoSuchElementException;
     18 import java.util.concurrent.BlockingQueue;
     19 import java.util.concurrent.CountDownLatch;
     20 import java.util.concurrent.Delayed;
     21 import java.util.concurrent.DelayQueue;
     22 import java.util.concurrent.Executors;
     23 import java.util.concurrent.ExecutorService;
     24 import java.util.concurrent.TimeUnit;
     25 
     26 import junit.framework.Test;
     27 
     28 public class DelayQueueTest extends JSR166TestCase {
     29 
     30     // android-changed: Extend BlockingQueueTest directly instead of creating
     31     // an inner class and its associated suite.
     32     //
     33     // public static class Generic extends BlockingQueueTest {
     34     //     protected BlockingQueue emptyCollection() {
     35     //         return new DelayQueue();
     36     //     }
     37     //     protected PDelay makeElement(int i) {
     38     //         return new PDelay(i);
     39     //     }
     40     // }
     41 
     42     // android-note: Removed because the CTS runner does a bad job of
     43     // retrying tests that have suite() declarations.
     44     //
     45     // public static void main(String[] args) {
     46     //     main(suite(), args);
     47     // }
     48     // public static Test suite() {
     49     //     return newTestSuite(DelayQueueTest.class,
     50     //                         new Generic().testSuite());
     51     // }
     52 
     53     protected BlockingQueue emptyCollection() {
     54         return new DelayQueue();
     55     }
     56 
     57     protected PDelay makeElement(int i) {
     58         return new PDelay(i);
     59     }
     60 
     61     /**
     62      * A delayed implementation for testing.
     63      * Most tests use Pseudodelays, where delays are all elapsed
     64      * (so, no blocking solely for delays) but are still ordered
     65      */
     66     static class PDelay implements Delayed {
     67         int pseudodelay;
     68         PDelay(int i) { pseudodelay = i; }
     69         public int compareTo(PDelay other) {
     70             int a = this.pseudodelay;
     71             int b = other.pseudodelay;
     72             return (a < b) ? -1 : (a > b) ? 1 : 0;
     73         }
     74         public int compareTo(Delayed y) {
     75             return compareTo((PDelay)y);
     76         }
     77         public boolean equals(Object other) {
     78             return (other instanceof PDelay) &&
     79                 this.pseudodelay == ((PDelay)other).pseudodelay;
     80         }
     81         // suppress [overrides] javac warning
     82         public int hashCode() { return pseudodelay; }
     83         public long getDelay(TimeUnit ignore) {
     84             return Integer.MIN_VALUE + pseudodelay;
     85         }
     86         public String toString() {
     87             return String.valueOf(pseudodelay);
     88         }
     89     }
     90 
     91     /**
     92      * Delayed implementation that actually delays
     93      */
     94     static class NanoDelay implements Delayed {
     95         long trigger;
     96         NanoDelay(long i) {
     97             trigger = System.nanoTime() + i;
     98         }
     99         public int compareTo(NanoDelay y) {
    100             long i = trigger;
    101             long j = y.trigger;
    102             if (i < j) return -1;
    103             if (i > j) return 1;
    104             return 0;
    105         }
    106 
    107         public int compareTo(Delayed y) {
    108             return compareTo((NanoDelay)y);
    109         }
    110 
    111         public boolean equals(Object other) {
    112             return equals((NanoDelay)other);
    113         }
    114         public boolean equals(NanoDelay other) {
    115             return other.trigger == trigger;
    116         }
    117 
    118         // suppress [overrides] javac warning
    119         public int hashCode() { return (int) trigger; }
    120 
    121         public long getDelay(TimeUnit unit) {
    122             long n = trigger - System.nanoTime();
    123             return unit.convert(n, TimeUnit.NANOSECONDS);
    124         }
    125 
    126         public long getTriggerTime() {
    127             return trigger;
    128         }
    129 
    130         public String toString() {
    131             return String.valueOf(trigger);
    132         }
    133     }
    134 
    135     /**
    136      * Returns a new queue of given size containing consecutive
    137      * PDelays 0 ... n.
    138      */
    139     private DelayQueue<PDelay> populatedQueue(int n) {
    140         DelayQueue<PDelay> q = new DelayQueue<PDelay>();
    141         assertTrue(q.isEmpty());
    142         for (int i = n - 1; i >= 0; i -= 2)
    143             assertTrue(q.offer(new PDelay(i)));
    144         for (int i = (n & 1); i < n; i += 2)
    145             assertTrue(q.offer(new PDelay(i)));
    146         assertFalse(q.isEmpty());
    147         assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
    148         assertEquals(n, q.size());
    149         return q;
    150     }
    151 
    152     /**
    153      * A new queue has unbounded capacity
    154      */
    155     public void testConstructor1() {
    156         assertEquals(Integer.MAX_VALUE, new DelayQueue().remainingCapacity());
    157     }
    158 
    159     /**
    160      * Initializing from null Collection throws NPE
    161      */
    162     public void testConstructor3() {
    163         try {
    164             new DelayQueue(null);
    165             shouldThrow();
    166         } catch (NullPointerException success) {}
    167     }
    168 
    169     /**
    170      * Initializing from Collection of null elements throws NPE
    171      */
    172     public void testConstructor4() {
    173         try {
    174             new DelayQueue(Arrays.asList(new PDelay[SIZE]));
    175             shouldThrow();
    176         } catch (NullPointerException success) {}
    177     }
    178 
    179     /**
    180      * Initializing from Collection with some null elements throws NPE
    181      */
    182     public void testConstructor5() {
    183         PDelay[] a = new PDelay[SIZE];
    184         for (int i = 0; i < SIZE - 1; ++i)
    185             a[i] = new PDelay(i);
    186         try {
    187             new DelayQueue(Arrays.asList(a));
    188             shouldThrow();
    189         } catch (NullPointerException success) {}
    190     }
    191 
    192     /**
    193      * Queue contains all elements of collection used to initialize
    194      */
    195     public void testConstructor6() {
    196         PDelay[] ints = new PDelay[SIZE];
    197         for (int i = 0; i < SIZE; ++i)
    198             ints[i] = new PDelay(i);
    199         DelayQueue q = new DelayQueue(Arrays.asList(ints));
    200         for (int i = 0; i < SIZE; ++i)
    201             assertEquals(ints[i], q.poll());
    202     }
    203 
    204     /**
    205      * isEmpty is true before add, false after
    206      */
    207     public void testEmpty() {
    208         DelayQueue q = new DelayQueue();
    209         assertTrue(q.isEmpty());
    210         assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
    211         q.add(new PDelay(1));
    212         assertFalse(q.isEmpty());
    213         q.add(new PDelay(2));
    214         q.remove();
    215         q.remove();
    216         assertTrue(q.isEmpty());
    217     }
    218 
    219     /**
    220      * remainingCapacity() always returns Integer.MAX_VALUE
    221      */
    222     public void testRemainingCapacity() {
    223         BlockingQueue q = populatedQueue(SIZE);
    224         for (int i = 0; i < SIZE; ++i) {
    225             assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
    226             assertEquals(SIZE - i, q.size());
    227             assertTrue(q.remove() instanceof PDelay);
    228         }
    229         for (int i = 0; i < SIZE; ++i) {
    230             assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
    231             assertEquals(i, q.size());
    232             assertTrue(q.add(new PDelay(i)));
    233         }
    234     }
    235 
    236     /**
    237      * offer non-null succeeds
    238      */
    239     public void testOffer() {
    240         DelayQueue q = new DelayQueue();
    241         assertTrue(q.offer(new PDelay(0)));
    242         assertTrue(q.offer(new PDelay(1)));
    243     }
    244 
    245     /**
    246      * add succeeds
    247      */
    248     public void testAdd() {
    249         DelayQueue q = new DelayQueue();
    250         for (int i = 0; i < SIZE; ++i) {
    251             assertEquals(i, q.size());
    252             assertTrue(q.add(new PDelay(i)));
    253         }
    254     }
    255 
    256     /**
    257      * addAll(this) throws IAE
    258      */
    259     public void testAddAllSelf() {
    260         DelayQueue q = populatedQueue(SIZE);
    261         try {
    262             q.addAll(q);
    263             shouldThrow();
    264         } catch (IllegalArgumentException success) {}
    265     }
    266 
    267     /**
    268      * addAll of a collection with any null elements throws NPE after
    269      * possibly adding some elements
    270      */
    271     public void testAddAll3() {
    272         DelayQueue q = new DelayQueue();
    273         PDelay[] a = new PDelay[SIZE];
    274         for (int i = 0; i < SIZE - 1; ++i)
    275             a[i] = new PDelay(i);
    276         try {
    277             q.addAll(Arrays.asList(a));
    278             shouldThrow();
    279         } catch (NullPointerException success) {}
    280     }
    281 
    282     /**
    283      * Queue contains all elements of successful addAll
    284      */
    285     public void testAddAll5() {
    286         PDelay[] empty = new PDelay[0];
    287         PDelay[] ints = new PDelay[SIZE];
    288         for (int i = SIZE - 1; i >= 0; --i)
    289             ints[i] = new PDelay(i);
    290         DelayQueue q = new DelayQueue();
    291         assertFalse(q.addAll(Arrays.asList(empty)));
    292         assertTrue(q.addAll(Arrays.asList(ints)));
    293         for (int i = 0; i < SIZE; ++i)
    294             assertEquals(ints[i], q.poll());
    295     }
    296 
    297     /**
    298      * all elements successfully put are contained
    299      */
    300     public void testPut() {
    301         DelayQueue q = new DelayQueue();
    302         for (int i = 0; i < SIZE; ++i) {
    303             PDelay x = new PDelay(i);
    304             q.put(x);
    305             assertTrue(q.contains(x));
    306         }
    307         assertEquals(SIZE, q.size());
    308     }
    309 
    310     /**
    311      * put doesn't block waiting for take
    312      */
    313     public void testPutWithTake() throws InterruptedException {
    314         final DelayQueue q = new DelayQueue();
    315         Thread t = newStartedThread(new CheckedRunnable() {
    316             public void realRun() {
    317                 q.put(new PDelay(0));
    318                 q.put(new PDelay(0));
    319                 q.put(new PDelay(0));
    320                 q.put(new PDelay(0));
    321             }});
    322 
    323         awaitTermination(t);
    324         assertEquals(4, q.size());
    325     }
    326 
    327     /**
    328      * timed offer does not time out
    329      */
    330     public void testTimedOffer() throws InterruptedException {
    331         final DelayQueue q = new DelayQueue();
    332         Thread t = newStartedThread(new CheckedRunnable() {
    333             public void realRun() throws InterruptedException {
    334                 q.put(new PDelay(0));
    335                 q.put(new PDelay(0));
    336                 assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS));
    337                 assertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, MILLISECONDS));
    338             }});
    339 
    340         awaitTermination(t);
    341     }
    342 
    343     /**
    344      * take retrieves elements in priority order
    345      */
    346     public void testTake() throws InterruptedException {
    347         DelayQueue q = populatedQueue(SIZE);
    348         for (int i = 0; i < SIZE; ++i) {
    349             assertEquals(new PDelay(i), q.take());
    350         }
    351     }
    352 
    353     /**
    354      * Take removes existing elements until empty, then blocks interruptibly
    355      */
    356     public void testBlockingTake() throws InterruptedException {
    357         final DelayQueue q = populatedQueue(SIZE);
    358         final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
    359         Thread t = newStartedThread(new CheckedRunnable() {
    360             public void realRun() throws InterruptedException {
    361                 for (int i = 0; i < SIZE; ++i) {
    362                     assertEquals(new PDelay(i), ((PDelay)q.take()));
    363                 }
    364 
    365                 Thread.currentThread().interrupt();
    366                 try {
    367                     q.take();
    368                     shouldThrow();
    369                 } catch (InterruptedException success) {}
    370                 assertFalse(Thread.interrupted());
    371 
    372                 pleaseInterrupt.countDown();
    373                 try {
    374                     q.take();
    375                     shouldThrow();
    376                 } catch (InterruptedException success) {}
    377                 assertFalse(Thread.interrupted());
    378             }});
    379 
    380         await(pleaseInterrupt);
    381         assertThreadStaysAlive(t);
    382         t.interrupt();
    383         awaitTermination(t);
    384     }
    385 
    386     /**
    387      * poll succeeds unless empty
    388      */
    389     public void testPoll() {
    390         DelayQueue q = populatedQueue(SIZE);
    391         for (int i = 0; i < SIZE; ++i) {
    392             assertEquals(new PDelay(i), q.poll());
    393         }
    394         assertNull(q.poll());
    395     }
    396 
    397     /**
    398      * timed poll with zero timeout succeeds when non-empty, else times out
    399      */
    400     public void testTimedPoll0() throws InterruptedException {
    401         DelayQueue q = populatedQueue(SIZE);
    402         for (int i = 0; i < SIZE; ++i) {
    403             assertEquals(new PDelay(i), q.poll(0, MILLISECONDS));
    404         }
    405         assertNull(q.poll(0, MILLISECONDS));
    406     }
    407 
    408     /**
    409      * timed poll with nonzero timeout succeeds when non-empty, else times out
    410      */
    411     public void testTimedPoll() throws InterruptedException {
    412         DelayQueue q = populatedQueue(SIZE);
    413         for (int i = 0; i < SIZE; ++i) {
    414             long startTime = System.nanoTime();
    415             assertEquals(new PDelay(i), q.poll(LONG_DELAY_MS, MILLISECONDS));
    416             assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
    417         }
    418         long startTime = System.nanoTime();
    419         assertNull(q.poll(timeoutMillis(), MILLISECONDS));
    420         assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
    421         checkEmpty(q);
    422     }
    423 
    424     /**
    425      * Interrupted timed poll throws InterruptedException instead of
    426      * returning timeout status
    427      */
    428     public void testInterruptedTimedPoll() throws InterruptedException {
    429         final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
    430         final DelayQueue q = populatedQueue(SIZE);
    431         Thread t = newStartedThread(new CheckedRunnable() {
    432             public void realRun() throws InterruptedException {
    433                 long startTime = System.nanoTime();
    434                 for (int i = 0; i < SIZE; ++i) {
    435                     assertEquals(new PDelay(i),
    436                                  ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
    437                 }
    438 
    439                 Thread.currentThread().interrupt();
    440                 try {
    441                     q.poll(LONG_DELAY_MS, MILLISECONDS);
    442                     shouldThrow();
    443                 } catch (InterruptedException success) {}
    444                 assertFalse(Thread.interrupted());
    445 
    446                 pleaseInterrupt.countDown();
    447                 try {
    448                     q.poll(LONG_DELAY_MS, MILLISECONDS);
    449                     shouldThrow();
    450                 } catch (InterruptedException success) {}
    451                 assertFalse(Thread.interrupted());
    452                 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
    453             }});
    454 
    455         await(pleaseInterrupt);
    456         assertThreadStaysAlive(t);
    457         t.interrupt();
    458         awaitTermination(t);
    459         checkEmpty(q);
    460     }
    461 
    462     /**
    463      * peek returns next element, or null if empty
    464      */
    465     public void testPeek() {
    466         DelayQueue q = populatedQueue(SIZE);
    467         for (int i = 0; i < SIZE; ++i) {
    468             assertEquals(new PDelay(i), q.peek());
    469             assertEquals(new PDelay(i), q.poll());
    470             if (q.isEmpty())
    471                 assertNull(q.peek());
    472             else
    473                 assertFalse(new PDelay(i).equals(q.peek()));
    474         }
    475         assertNull(q.peek());
    476     }
    477 
    478     /**
    479      * element returns next element, or throws NSEE if empty
    480      */
    481     public void testElement() {
    482         DelayQueue q = populatedQueue(SIZE);
    483         for (int i = 0; i < SIZE; ++i) {
    484             assertEquals(new PDelay(i), q.element());
    485             q.poll();
    486         }
    487         try {
    488             q.element();
    489             shouldThrow();
    490         } catch (NoSuchElementException success) {}
    491     }
    492 
    493     /**
    494      * remove removes next element, or throws NSEE if empty
    495      */
    496     public void testRemove() {
    497         DelayQueue q = populatedQueue(SIZE);
    498         for (int i = 0; i < SIZE; ++i) {
    499             assertEquals(new PDelay(i), q.remove());
    500         }
    501         try {
    502             q.remove();
    503             shouldThrow();
    504         } catch (NoSuchElementException success) {}
    505     }
    506 
    507     /**
    508      * contains(x) reports true when elements added but not yet removed
    509      */
    510     public void testContains() {
    511         DelayQueue q = populatedQueue(SIZE);
    512         for (int i = 0; i < SIZE; ++i) {
    513             assertTrue(q.contains(new PDelay(i)));
    514             q.poll();
    515             assertFalse(q.contains(new PDelay(i)));
    516         }
    517     }
    518 
    519     /**
    520      * clear removes all elements
    521      */
    522     public void testClear() {
    523         DelayQueue q = populatedQueue(SIZE);
    524         q.clear();
    525         assertTrue(q.isEmpty());
    526         assertEquals(0, q.size());
    527         assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
    528         PDelay x = new PDelay(1);
    529         q.add(x);
    530         assertFalse(q.isEmpty());
    531         assertTrue(q.contains(x));
    532         q.clear();
    533         assertTrue(q.isEmpty());
    534     }
    535 
    536     /**
    537      * containsAll(c) is true when c contains a subset of elements
    538      */
    539     public void testContainsAll() {
    540         DelayQueue q = populatedQueue(SIZE);
    541         DelayQueue p = new DelayQueue();
    542         for (int i = 0; i < SIZE; ++i) {
    543             assertTrue(q.containsAll(p));
    544             assertFalse(p.containsAll(q));
    545             p.add(new PDelay(i));
    546         }
    547         assertTrue(p.containsAll(q));
    548     }
    549 
    550     /**
    551      * retainAll(c) retains only those elements of c and reports true if changed
    552      */
    553     public void testRetainAll() {
    554         DelayQueue q = populatedQueue(SIZE);
    555         DelayQueue p = populatedQueue(SIZE);
    556         for (int i = 0; i < SIZE; ++i) {
    557             boolean changed = q.retainAll(p);
    558             if (i == 0)
    559                 assertFalse(changed);
    560             else
    561                 assertTrue(changed);
    562 
    563             assertTrue(q.containsAll(p));
    564             assertEquals(SIZE - i, q.size());
    565             p.remove();
    566         }
    567     }
    568 
    569     /**
    570      * removeAll(c) removes only those elements of c and reports true if changed
    571      */
    572     public void testRemoveAll() {
    573         for (int i = 1; i < SIZE; ++i) {
    574             DelayQueue q = populatedQueue(SIZE);
    575             DelayQueue p = populatedQueue(i);
    576             assertTrue(q.removeAll(p));
    577             assertEquals(SIZE - i, q.size());
    578             for (int j = 0; j < i; ++j) {
    579                 PDelay x = (PDelay)(p.remove());
    580                 assertFalse(q.contains(x));
    581             }
    582         }
    583     }
    584 
    585     /**
    586      * toArray contains all elements
    587      */
    588     public void testToArray() throws InterruptedException {
    589         DelayQueue q = populatedQueue(SIZE);
    590         Object[] o = q.toArray();
    591         Arrays.sort(o);
    592         for (int i = 0; i < o.length; i++)
    593             assertSame(o[i], q.take());
    594     }
    595 
    596     /**
    597      * toArray(a) contains all elements
    598      */
    599     public void testToArray2() {
    600         DelayQueue<PDelay> q = populatedQueue(SIZE);
    601         PDelay[] ints = new PDelay[SIZE];
    602         PDelay[] array = q.toArray(ints);
    603         assertSame(ints, array);
    604         Arrays.sort(ints);
    605         for (int i = 0; i < ints.length; i++)
    606             assertSame(ints[i], q.remove());
    607     }
    608 
    609     /**
    610      * toArray(incompatible array type) throws ArrayStoreException
    611      */
    612     public void testToArray1_BadArg() {
    613         DelayQueue q = populatedQueue(SIZE);
    614         try {
    615             q.toArray(new String[10]);
    616             shouldThrow();
    617         } catch (ArrayStoreException success) {}
    618     }
    619 
    620     /**
    621      * iterator iterates through all elements
    622      */
    623     public void testIterator() {
    624         DelayQueue q = populatedQueue(SIZE);
    625         int i = 0;
    626         Iterator it = q.iterator();
    627         while (it.hasNext()) {
    628             assertTrue(q.contains(it.next()));
    629             ++i;
    630         }
    631         assertEquals(i, SIZE);
    632         assertIteratorExhausted(it);
    633     }
    634 
    635     /**
    636      * iterator of empty collection has no elements
    637      */
    638     public void testEmptyIterator() {
    639         assertIteratorExhausted(new DelayQueue().iterator());
    640     }
    641 
    642     /**
    643      * iterator.remove removes current element
    644      */
    645     public void testIteratorRemove() {
    646         final DelayQueue q = new DelayQueue();
    647         q.add(new PDelay(2));
    648         q.add(new PDelay(1));
    649         q.add(new PDelay(3));
    650         Iterator it = q.iterator();
    651         it.next();
    652         it.remove();
    653         it = q.iterator();
    654         assertEquals(new PDelay(2), it.next());
    655         assertEquals(new PDelay(3), it.next());
    656         assertFalse(it.hasNext());
    657     }
    658 
    659     /**
    660      * toString contains toStrings of elements
    661      */
    662     public void testToString() {
    663         DelayQueue q = populatedQueue(SIZE);
    664         String s = q.toString();
    665         for (Object e : q)
    666             assertTrue(s.contains(e.toString()));
    667     }
    668 
    669     /**
    670      * timed poll transfers elements across Executor tasks
    671      */
    672     public void testPollInExecutor() {
    673         final DelayQueue q = new DelayQueue();
    674         final CheckedBarrier threadsStarted = new CheckedBarrier(2);
    675         final ExecutorService executor = Executors.newFixedThreadPool(2);
    676         try (PoolCleaner cleaner = cleaner(executor)) {
    677             executor.execute(new CheckedRunnable() {
    678                 public void realRun() throws InterruptedException {
    679                     assertNull(q.poll());
    680                     threadsStarted.await();
    681                     assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
    682                     checkEmpty(q);
    683                 }});
    684 
    685             executor.execute(new CheckedRunnable() {
    686                 public void realRun() throws InterruptedException {
    687                     threadsStarted.await();
    688                     q.put(new PDelay(1));
    689                 }});
    690         }
    691     }
    692 
    693     /**
    694      * Delayed actions do not occur until their delay elapses
    695      */
    696     public void testDelay() throws InterruptedException {
    697         DelayQueue<NanoDelay> q = new DelayQueue<NanoDelay>();
    698         for (int i = 0; i < SIZE; ++i)
    699             q.add(new NanoDelay(1000000L * (SIZE - i)));
    700 
    701         long last = 0;
    702         for (int i = 0; i < SIZE; ++i) {
    703             NanoDelay e = q.take();
    704             long tt = e.getTriggerTime();
    705             assertTrue(System.nanoTime() - tt >= 0);
    706             if (i != 0)
    707                 assertTrue(tt >= last);
    708             last = tt;
    709         }
    710         assertTrue(q.isEmpty());
    711     }
    712 
    713     /**
    714      * peek of a non-empty queue returns non-null even if not expired
    715      */
    716     public void testPeekDelayed() {
    717         DelayQueue q = new DelayQueue();
    718         q.add(new NanoDelay(Long.MAX_VALUE));
    719         assertNotNull(q.peek());
    720     }
    721 
    722     /**
    723      * poll of a non-empty queue returns null if no expired elements.
    724      */
    725     public void testPollDelayed() {
    726         DelayQueue q = new DelayQueue();
    727         q.add(new NanoDelay(Long.MAX_VALUE));
    728         assertNull(q.poll());
    729     }
    730 
    731     /**
    732      * timed poll of a non-empty queue returns null if no expired elements.
    733      */
    734     public void testTimedPollDelayed() throws InterruptedException {
    735         DelayQueue q = new DelayQueue();
    736         q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
    737         assertNull(q.poll(timeoutMillis(), MILLISECONDS));
    738     }
    739 
    740     /**
    741      * drainTo(c) empties queue into another collection c
    742      */
    743     public void testDrainTo() {
    744         DelayQueue q = new DelayQueue();
    745         PDelay[] elems = new PDelay[SIZE];
    746         for (int i = 0; i < SIZE; ++i) {
    747             elems[i] = new PDelay(i);
    748             q.add(elems[i]);
    749         }
    750         ArrayList l = new ArrayList();
    751         q.drainTo(l);
    752         assertEquals(0, q.size());
    753         for (int i = 0; i < SIZE; ++i)
    754             assertEquals(elems[i], l.get(i));
    755         q.add(elems[0]);
    756         q.add(elems[1]);
    757         assertFalse(q.isEmpty());
    758         assertTrue(q.contains(elems[0]));
    759         assertTrue(q.contains(elems[1]));
    760         l.clear();
    761         q.drainTo(l);
    762         assertEquals(0, q.size());
    763         assertEquals(2, l.size());
    764         for (int i = 0; i < 2; ++i)
    765             assertEquals(elems[i], l.get(i));
    766     }
    767 
    768     /**
    769      * drainTo empties queue
    770      */
    771     public void testDrainToWithActivePut() throws InterruptedException {
    772         final DelayQueue q = populatedQueue(SIZE);
    773         Thread t = new Thread(new CheckedRunnable() {
    774             public void realRun() {
    775                 q.put(new PDelay(SIZE + 1));
    776             }});
    777 
    778         t.start();
    779         ArrayList l = new ArrayList();
    780         q.drainTo(l);
    781         assertTrue(l.size() >= SIZE);
    782         t.join();
    783         assertTrue(q.size() + l.size() >= SIZE);
    784     }
    785 
    786     /**
    787      * drainTo(c, n) empties first min(n, size) elements of queue into c
    788      */
    789     public void testDrainToN() {
    790         for (int i = 0; i < SIZE + 2; ++i) {
    791             DelayQueue q = populatedQueue(SIZE);
    792             ArrayList l = new ArrayList();
    793             q.drainTo(l, i);
    794             int k = (i < SIZE) ? i : SIZE;
    795             assertEquals(SIZE - k, q.size());
    796             assertEquals(k, l.size());
    797         }
    798     }
    799 
    800     /**
    801      * remove(null), contains(null) always return false
    802      */
    803     public void testNeverContainsNull() {
    804         Collection<?> q = populatedQueue(SIZE);
    805         assertFalse(q.contains(null));
    806         assertFalse(q.remove(null));
    807     }
    808 }
    809