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.52 by jsr166, Sat May 28 22:40:00 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 507 | Line 449 | public class DelayQueueTest extends JSR1
449      }
450  
451      /**
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(timeoutMillis(), 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 –    /**
452       * peek returns next element, or null if empty
453       */
454      public void testPeek() {
# Line 710 | Line 611 | public class DelayQueueTest extends JSR1
611      }
612  
613      /**
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 –    /**
614       * toArray(incompatible array type) throws ArrayStoreException
615       */
616      public void testToArray1_BadArg() {
# Line 845 | Line 735 | public class DelayQueueTest extends JSR1
735      }
736  
737      /**
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) {}
867 –    }
868 –
869 –    /**
738       * drainTo(c) empties queue into another collection c
739       */
740      public void testDrainTo() {
# Line 913 | Line 781 | public class DelayQueueTest extends JSR1
781      }
782  
783      /**
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 –    /**
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