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.51 by jsr166, Sat May 28 12:45:38 2011 UTC vs.
Revision 1.54 by jsr166, Tue May 31 16:16:23 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.Iterator;
13 > import java.util.NoSuchElementException;
14 > import java.util.concurrent.BlockingQueue;
15 > import java.util.concurrent.CountDownLatch;
16 > import java.util.concurrent.Delayed;
17 > import java.util.concurrent.DelayQueue;
18 > import java.util.concurrent.Executors;
19 > import java.util.concurrent.ExecutorService;
20 > import java.util.concurrent.TimeUnit;
21   import static java.util.concurrent.TimeUnit.MILLISECONDS;
12 – import java.util.concurrent.*;
22  
23   public class DelayQueueTest extends JSR166TestCase {
24 +
25 +    public static class Generic extends BlockingQueueTest {
26 +        protected BlockingQueue emptyCollection() {
27 +            return new DelayQueue();
28 +        }
29 +        protected PDelay makeElement(int i) {
30 +            return new PDelay(i);
31 +        }
32 +    }
33 +
34      public static void main(String[] args) {
35          junit.textui.TestRunner.run(suite());
36      }
37  
38      public static Test suite() {
39 <        return new TestSuite(DelayQueueTest.class);
39 >        return newTestSuite(DelayQueueTest.class,
40 >                            new Generic().testSuite());
41      }
42  
43      private static final int NOCAP = Integer.MAX_VALUE;
# Line 206 | Line 226 | public class DelayQueueTest extends JSR1
226      }
227  
228      /**
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 –    /**
229       * offer non-null succeeds
230       */
231      public void testOffer() {
# Line 248 | Line 246 | public class DelayQueueTest extends JSR1
246      }
247  
248      /**
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 –    /**
249       * addAll(this) throws IAE
250       */
251      public void testAddAllSelf() {
# Line 270 | Line 257 | public class DelayQueueTest extends JSR1
257      }
258  
259      /**
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 –    /**
260       * addAll of a collection with any null elements throws NPE after
261       * possibly adding some elements
262       */
# Line 312 | Line 287 | public class DelayQueueTest extends JSR1
287      }
288  
289      /**
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 –    /**
290       * all elements successfully put are contained
291       */
292      public void testPut() {
# Line 379 | Line 343 | public class DelayQueueTest extends JSR1
343      }
344  
345      /**
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 –    /**
346       * Take removes existing elements until empty, then blocks interruptibly
347       */
348      public void testBlockingTake() throws InterruptedException {
# Line 507 | Line 448 | public class DelayQueueTest extends JSR1
448      }
449  
450      /**
510 –     * timed poll before a delayed offer fails; after offer succeeds;
511 –     * on interruption throws
512 –     */
513 –    public void testTimedPollWithOffer() throws InterruptedException {
514 –        final DelayQueue q = new DelayQueue();
515 –        final PDelay pdelay = new PDelay(0);
516 –        final CheckedBarrier barrier = new CheckedBarrier(2);
517 –        Thread t = newStartedThread(new CheckedRunnable() {
518 –            public void realRun() throws InterruptedException {
519 –                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
520 –
521 –                barrier.await();
522 –                assertSame(pdelay, q.poll(LONG_DELAY_MS, MILLISECONDS));
523 –
524 –                Thread.currentThread().interrupt();
525 –                try {
526 –                    q.poll(LONG_DELAY_MS, MILLISECONDS);
527 –                    shouldThrow();
528 –                } catch (InterruptedException success) {}
529 –                assertFalse(Thread.interrupted());
530 –
531 –                barrier.await();
532 –                try {
533 –                    q.poll(LONG_DELAY_MS, MILLISECONDS);
534 –                    shouldThrow();
535 –                } catch (InterruptedException success) {}
536 –                assertFalse(Thread.interrupted());
537 –            }});
538 –
539 –        barrier.await();
540 –        long startTime = System.nanoTime();
541 –        assertTrue(q.offer(pdelay, LONG_DELAY_MS, MILLISECONDS));
542 –        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
543 –
544 –        barrier.await();
545 –        assertThreadStaysAlive(t);
546 –        t.interrupt();
547 –        awaitTermination(t);
548 –    }
549 –
550 –    /**
451       * peek returns next element, or null if empty
452       */
453      public void testPeek() {
# Line 710 | Line 610 | public class DelayQueueTest extends JSR1
610      }
611  
612      /**
713 –     * toArray(null) throws NullPointerException
714 –     */
715 –    public void testToArray_NullArg() {
716 –        DelayQueue q = populatedQueue(SIZE);
717 –        try {
718 –            q.toArray(null);
719 –            shouldThrow();
720 –        } catch (NullPointerException success) {}
721 –    }
722 –
723 –    /**
613       * toArray(incompatible array type) throws ArrayStoreException
614       */
615      public void testToArray1_BadArg() {
# Line 841 | Line 730 | public class DelayQueueTest extends JSR1
730      public void testTimedPollDelayed() throws InterruptedException {
731          DelayQueue q = new DelayQueue();
732          q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
733 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
845 <    }
846 <
847 <    /**
848 <     * drainTo(null) throws NPE
849 <     */
850 <    public void testDrainToNull() {
851 <        DelayQueue q = populatedQueue(SIZE);
852 <        try {
853 <            q.drainTo(null);
854 <            shouldThrow();
855 <        } catch (NullPointerException success) {}
856 <    }
857 <
858 <    /**
859 <     * drainTo(this) throws IAE
860 <     */
861 <    public void testDrainToSelf() {
862 <        DelayQueue q = populatedQueue(SIZE);
863 <        try {
864 <            q.drainTo(q);
865 <            shouldThrow();
866 <        } catch (IllegalArgumentException success) {}
733 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
734      }
735  
736      /**
# Line 913 | Line 780 | public class DelayQueueTest extends JSR1
780      }
781  
782      /**
916 –     * drainTo(null, n) throws NPE
917 –     */
918 –    public void testDrainToNullN() {
919 –        DelayQueue q = populatedQueue(SIZE);
920 –        try {
921 –            q.drainTo(null, 0);
922 –            shouldThrow();
923 –        } catch (NullPointerException success) {}
924 –    }
925 –
926 –    /**
927 –     * drainTo(this, n) throws IAE
928 –     */
929 –    public void testDrainToSelfN() {
930 –        DelayQueue q = populatedQueue(SIZE);
931 –        try {
932 –            q.drainTo(q, 0);
933 –            shouldThrow();
934 –        } catch (IllegalArgumentException success) {}
935 –    }
936 –
937 –    /**
783       * drainTo(c, n) empties first min(n, size) elements of queue into c
784       */
785      public void testDrainToN() {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines