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

Comparing jsr166/src/test/tck/PriorityBlockingQueueTest.java (file contents):
Revision 1.26 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.38 by jsr166, Fri Nov 5 00:17:22 2010 UTC

# Line 13 | Line 13 | import static java.util.concurrent.TimeU
13   import java.io.*;
14  
15   public class PriorityBlockingQueueTest extends JSR166TestCase {
16 +
17 +    public static class Generic extends BlockingQueueTest {
18 +        protected BlockingQueue emptyCollection() {
19 +            return new PriorityBlockingQueue();
20 +        }
21 +    }
22 +
23 +    public static class InitialCapacity extends BlockingQueueTest {
24 +        protected BlockingQueue emptyCollection() {
25 +            return new PriorityBlockingQueue(20);
26 +        }
27 +    }
28 +
29      public static void main(String[] args) {
30          junit.textui.TestRunner.run(suite());
31      }
32 +
33      public static Test suite() {
34 <        return new TestSuite(PriorityBlockingQueueTest.class);
34 >        return newTestSuite(PriorityBlockingQueueTest.class,
35 >                            new Generic().testSuite(),
36 >                            new InitialCapacity().testSuite());
37      }
38  
39      private static final int NOCAP = Integer.MAX_VALUE;
# Line 33 | Line 49 | public class PriorityBlockingQueueTest e
49       * Create a queue of given size containing consecutive
50       * Integers 0 ... n.
51       */
52 <    private PriorityBlockingQueue populatedQueue(int n) {
53 <        PriorityBlockingQueue q = new PriorityBlockingQueue(n);
52 >    private PriorityBlockingQueue<Integer> populatedQueue(int n) {
53 >        PriorityBlockingQueue<Integer> q =
54 >            new PriorityBlockingQueue<Integer>(n);
55          assertTrue(q.isEmpty());
56          for (int i = n-1; i >= 0; i-=2)
57              assertTrue(q.offer(new Integer(i)));
# Line 245 | Line 262 | public class PriorityBlockingQueueTest e
262              shouldThrow();
263          } catch (NullPointerException success) {}
264      }
265 +
266      /**
267       * addAll of a collection with any null elements throws NPE after
268       * possibly adding some elements
# Line 349 | Line 367 | public class PriorityBlockingQueueTest e
367      }
368  
369      /**
352 –     * take blocks interruptibly when empty
353 –     */
354 –    public void testTakeFromEmpty() throws InterruptedException {
355 –        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
356 –        Thread t = new Thread(new CheckedInterruptedRunnable() {
357 –            public void realRun() throws InterruptedException {
358 –                q.take();
359 –            }});
360 –
361 –        t.start();
362 –        Thread.sleep(SHORT_DELAY_MS);
363 –        t.interrupt();
364 –        t.join();
365 –    }
366 –
367 –    /**
370       * Take removes existing elements until empty, then blocks interruptibly
371       */
372      public void testBlockingTake() throws InterruptedException {
# Line 399 | Line 401 | public class PriorityBlockingQueueTest e
401      }
402  
403      /**
404 <     * timed pool with zero timeout succeeds when non-empty, else times out
404 >     * timed poll with zero timeout succeeds when non-empty, else times out
405       */
406      public void testTimedPoll0() throws InterruptedException {
407          PriorityBlockingQueue q = populatedQueue(SIZE);
# Line 410 | Line 412 | public class PriorityBlockingQueueTest e
412      }
413  
414      /**
415 <     * timed pool with nonzero timeout succeeds when non-empty, else times out
415 >     * timed poll with nonzero timeout succeeds when non-empty, else times out
416       */
417      public void testTimedPoll() throws InterruptedException {
418          PriorityBlockingQueue q = populatedQueue(SIZE);
# Line 444 | Line 446 | public class PriorityBlockingQueueTest e
446      }
447  
448      /**
447 –     *  timed poll before a delayed offer fails; after offer succeeds;
448 –     *  on interruption throws
449 –     */
450 –    public void testTimedPollWithOffer() throws InterruptedException {
451 –        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
452 –        Thread t = new Thread(new CheckedRunnable() {
453 –            public void realRun() throws InterruptedException {
454 –                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
455 –                assertSame(zero, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
456 –                try {
457 –                    q.poll(LONG_DELAY_MS, MILLISECONDS);
458 –                    shouldThrow();
459 –                } catch (InterruptedException success) {}
460 –            }});
461 –
462 –        t.start();
463 –        Thread.sleep(SMALL_DELAY_MS);
464 –        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
465 –        t.interrupt();
466 –        t.join();
467 –    }
468 –
469 –
470 –    /**
449       * peek returns next element, or null if empty
450       */
451      public void testPeek() {
# Line 602 | Line 580 | public class PriorityBlockingQueueTest e
580      }
581  
582      /**
583 <     *  toArray contains all elements
583 >     * toArray contains all elements
584       */
585      public void testToArray() throws InterruptedException {
586          PriorityBlockingQueue q = populatedQueue(SIZE);
587          Object[] o = q.toArray();
588          Arrays.sort(o);
589          for (int i = 0; i < o.length; i++)
590 <            assertEquals(o[i], q.take());
590 >            assertSame(o[i], q.take());
591      }
592  
593      /**
594       * toArray(a) contains all elements
595       */
596      public void testToArray2() throws InterruptedException {
597 <        PriorityBlockingQueue q = populatedQueue(SIZE);
597 >        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
598          Integer[] ints = new Integer[SIZE];
599 <        ints = (Integer[])q.toArray(ints);
599 >        Integer[] array = q.toArray(ints);
600 >        assertSame(ints, array);
601          Arrays.sort(ints);
602          for (int i = 0; i < ints.length; i++)
603 <            assertEquals(ints[i], q.take());
603 >            assertSame(ints[i], q.take());
604      }
605  
606      /**
607 <     * toArray(null) throws NPE
607 >     * toArray(null) throws NullPointerException
608       */
609 <    public void testToArray_BadArg() {
609 >    public void testToArray_NullArg() {
610          PriorityBlockingQueue q = populatedQueue(SIZE);
611          try {
612 <            Object o[] = q.toArray(null);
612 >            q.toArray(null);
613              shouldThrow();
614          } catch (NullPointerException success) {}
615      }
616  
617      /**
618 <     * toArray with incompatible array type throws CCE
618 >     * toArray(incompatible array type) throws ArrayStoreException
619       */
620      public void testToArray1_BadArg() {
621          PriorityBlockingQueue q = populatedQueue(SIZE);
622          try {
623 <            Object o[] = q.toArray(new String[10]);
623 >            q.toArray(new String[10]);
624              shouldThrow();
625          } catch (ArrayStoreException success) {}
626      }
# Line 820 | Line 799 | public class PriorityBlockingQueueTest e
799      }
800  
801      /**
802 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
802 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
803       */
804      public void testDrainToN() {
805          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
# Line 829 | Line 808 | public class PriorityBlockingQueueTest e
808                  assertTrue(q.offer(new Integer(j)));
809              ArrayList l = new ArrayList();
810              q.drainTo(l, i);
811 <            int k = (i < SIZE)? i : SIZE;
811 >            int k = (i < SIZE) ? i : SIZE;
812              assertEquals(l.size(), k);
813              assertEquals(q.size(), SIZE-k);
814              for (int j = 0; j < k; ++j)

Diff Legend

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