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.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 462 | Line 403 | public class DelayQueueTest extends JSR1
403      public void testTimedPoll() throws InterruptedException {
404          DelayQueue q = populatedQueue(SIZE);
405          for (int i = 0; i < SIZE; ++i) {
406 <            assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
406 >            long startTime = System.nanoTime();
407 >            assertEquals(new PDelay(i), ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
408 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
409          }
410 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
410 >        long startTime = System.nanoTime();
411 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
412 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
413 >        checkEmpty(q);
414      }
415  
416      /**
# Line 502 | Line 448 | public class DelayQueueTest extends JSR1
448      }
449  
450      /**
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 –    /**
451       * peek returns next element, or null if empty
452       */
453      public void testPeek() {
# Line 705 | Line 610 | public class DelayQueueTest extends JSR1
610      }
611  
612      /**
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 –    /**
613       * toArray(incompatible array type) throws ArrayStoreException
614       */
615      public void testToArray1_BadArg() {
# Line 836 | 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));
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) {}
733 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
734      }
735  
736      /**
# Line 908 | Line 780 | public class DelayQueueTest extends JSR1
780      }
781  
782      /**
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 –    /**
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