ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/DelayQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/DelayQueueTest.java (file contents):
Revision 1.50 by jsr166, Fri May 27 20:07:24 2011 UTC vs.
Revision 1.53 by jsr166, Mon May 30 22:43:20 2011 UTC

# Line 7 | Line 7
7   */
8  
9   import junit.framework.*;
10 < import java.util.*;
10 > import java.util.Arrays;
11 > import java.util.ArrayList;
12 > import java.util.Collection;
13 > import java.util.Iterator;
14 > import java.util.NoSuchElementException;
15 > import java.util.concurrent.BlockingQueue;
16 > import java.util.concurrent.CountDownLatch;
17 > import java.util.concurrent.Delayed;
18 > import java.util.concurrent.DelayQueue;
19 > import java.util.concurrent.Executors;
20 > import java.util.concurrent.ExecutorService;
21 > import java.util.concurrent.TimeUnit;
22   import static java.util.concurrent.TimeUnit.MILLISECONDS;
12 import java.util.concurrent.*;
23  
24   public class DelayQueueTest extends JSR166TestCase {
25 +
26 +    public static class Generic extends BlockingQueueTest {
27 +        protected BlockingQueue emptyCollection() {
28 +            return new DelayQueue();
29 +        }
30 +        protected PDelay makeElement(int i) {
31 +            return new PDelay(i);
32 +        }
33 +    }
34 +
35      public static void main(String[] args) {
36          junit.textui.TestRunner.run(suite());
37      }
38  
39      public static Test suite() {
40 <        return new TestSuite(DelayQueueTest.class);
40 >        return newTestSuite(DelayQueueTest.class,
41 >                            new Generic().testSuite());
42      }
43  
44      private static final int NOCAP = Integer.MAX_VALUE;
# Line 206 | Line 227 | public class DelayQueueTest extends JSR1
227      }
228  
229      /**
209     * offer(null) throws NPE
210     */
211    public void testOfferNull() {
212        try {
213            DelayQueue q = new DelayQueue();
214            q.offer(null);
215            shouldThrow();
216        } catch (NullPointerException success) {}
217    }
218
219    /**
220     * add(null) throws NPE
221     */
222    public void testAddNull() {
223        try {
224            DelayQueue q = new DelayQueue();
225            q.add(null);
226            shouldThrow();
227        } catch (NullPointerException success) {}
228    }
229
230    /**
230       * offer non-null succeeds
231       */
232      public void testOffer() {
# Line 248 | Line 247 | public class DelayQueueTest extends JSR1
247      }
248  
249      /**
251     * addAll(null) throws NPE
252     */
253    public void testAddAll1() {
254        try {
255            DelayQueue q = new DelayQueue();
256            q.addAll(null);
257            shouldThrow();
258        } catch (NullPointerException success) {}
259    }
260
261    /**
250       * addAll(this) throws IAE
251       */
252      public void testAddAllSelf() {
# Line 270 | Line 258 | public class DelayQueueTest extends JSR1
258      }
259  
260      /**
273     * addAll of a collection with null elements throws NPE
274     */
275    public void testAddAll2() {
276        try {
277            DelayQueue q = new DelayQueue();
278            PDelay[] ints = new PDelay[SIZE];
279            q.addAll(Arrays.asList(ints));
280            shouldThrow();
281        } catch (NullPointerException success) {}
282    }
283
284    /**
261       * addAll of a collection with any null elements throws NPE after
262       * possibly adding some elements
263       */
# Line 312 | Line 288 | public class DelayQueueTest extends JSR1
288      }
289  
290      /**
315     * put(null) throws NPE
316     */
317    public void testPutNull() {
318        try {
319            DelayQueue q = new DelayQueue();
320            q.put(null);
321            shouldThrow();
322        } catch (NullPointerException success) {}
323    }
324
325    /**
291       * all elements successfully put are contained
292       */
293      public void testPut() {
# Line 379 | Line 344 | public class DelayQueueTest extends JSR1
344      }
345  
346      /**
382     * take blocks interruptibly when empty
383     */
384    public void testTakeFromEmptyBlocksInterruptibly()
385            throws InterruptedException {
386        final BlockingQueue q = new DelayQueue();
387        final CountDownLatch threadStarted = new CountDownLatch(1);
388        Thread t = newStartedThread(new CheckedRunnable() {
389            public void realRun() {
390                threadStarted.countDown();
391                try {
392                    q.take();
393                    shouldThrow();
394                } catch (InterruptedException success) {}
395                assertFalse(Thread.interrupted());
396            }});
397
398        await(threadStarted);
399        assertThreadStaysAlive(t);
400        t.interrupt();
401        awaitTermination(t);
402    }
403
404    /**
347       * Take removes existing elements until empty, then blocks interruptibly
348       */
349      public void testBlockingTake() throws InterruptedException {
# Line 462 | Line 404 | public class DelayQueueTest extends JSR1
404      public void testTimedPoll() throws InterruptedException {
405          DelayQueue q = populatedQueue(SIZE);
406          for (int i = 0; i < SIZE; ++i) {
407 <            assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
407 >            long startTime = System.nanoTime();
408 >            assertEquals(new PDelay(i), ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
409 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
410          }
411 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
411 >        long startTime = System.nanoTime();
412 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
413 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
414 >        checkEmpty(q);
415      }
416  
417      /**
# Line 502 | Line 449 | public class DelayQueueTest extends JSR1
449      }
450  
451      /**
505     * timed poll before a delayed offer fails; after offer succeeds;
506     * on interruption throws
507     */
508    public void testTimedPollWithOffer() throws InterruptedException {
509        final DelayQueue q = new DelayQueue();
510        final PDelay pdelay = new PDelay(0);
511        final CheckedBarrier barrier = new CheckedBarrier(2);
512        Thread t = newStartedThread(new CheckedRunnable() {
513            public void realRun() throws InterruptedException {
514                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
515
516                barrier.await();
517                assertSame(pdelay, q.poll(LONG_DELAY_MS, MILLISECONDS));
518
519                Thread.currentThread().interrupt();
520                try {
521                    q.poll(LONG_DELAY_MS, MILLISECONDS);
522                    shouldThrow();
523                } catch (InterruptedException success) {}
524                assertFalse(Thread.interrupted());
525
526                barrier.await();
527                try {
528                    q.poll(LONG_DELAY_MS, MILLISECONDS);
529                    shouldThrow();
530                } catch (InterruptedException success) {}
531                assertFalse(Thread.interrupted());
532            }});
533
534        barrier.await();
535        long startTime = System.nanoTime();
536        assertTrue(q.offer(pdelay, LONG_DELAY_MS, MILLISECONDS));
537        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
538
539        barrier.await();
540        assertThreadStaysAlive(t);
541        t.interrupt();
542        awaitTermination(t);
543    }
544
545    /**
452       * peek returns next element, or null if empty
453       */
454      public void testPeek() {
# Line 705 | Line 611 | public class DelayQueueTest extends JSR1
611      }
612  
613      /**
708     * toArray(null) throws NullPointerException
709     */
710    public void testToArray_NullArg() {
711        DelayQueue q = populatedQueue(SIZE);
712        try {
713            q.toArray(null);
714            shouldThrow();
715        } catch (NullPointerException success) {}
716    }
717
718    /**
614       * toArray(incompatible array type) throws ArrayStoreException
615       */
616      public void testToArray1_BadArg() {
# Line 836 | Line 731 | public class DelayQueueTest extends JSR1
731      public void testTimedPollDelayed() throws InterruptedException {
732          DelayQueue q = new DelayQueue();
733          q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
734 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
840 <    }
841 <
842 <    /**
843 <     * drainTo(null) throws NPE
844 <     */
845 <    public void testDrainToNull() {
846 <        DelayQueue q = populatedQueue(SIZE);
847 <        try {
848 <            q.drainTo(null);
849 <            shouldThrow();
850 <        } catch (NullPointerException success) {}
851 <    }
852 <
853 <    /**
854 <     * drainTo(this) throws IAE
855 <     */
856 <    public void testDrainToSelf() {
857 <        DelayQueue q = populatedQueue(SIZE);
858 <        try {
859 <            q.drainTo(q);
860 <            shouldThrow();
861 <        } catch (IllegalArgumentException success) {}
734 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
735      }
736  
737      /**
# Line 908 | Line 781 | public class DelayQueueTest extends JSR1
781      }
782  
783      /**
911     * drainTo(null, n) throws NPE
912     */
913    public void testDrainToNullN() {
914        DelayQueue q = populatedQueue(SIZE);
915        try {
916            q.drainTo(null, 0);
917            shouldThrow();
918        } catch (NullPointerException success) {}
919    }
920
921    /**
922     * drainTo(this, n) throws IAE
923     */
924    public void testDrainToSelfN() {
925        DelayQueue q = populatedQueue(SIZE);
926        try {
927            q.drainTo(q, 0);
928            shouldThrow();
929        } catch (IllegalArgumentException success) {}
930    }
931
932    /**
784       * drainTo(c, n) empties first min(n, size) elements of queue into c
785       */
786      public void testDrainToN() {

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines