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.16 by jsr166, Sat Nov 21 02:07:27 2009 UTC vs.
Revision 1.40 by jsr166, Sun Nov 28 08:43:53 2010 UTC

# Line 9 | Line 9
9   import junit.framework.*;
10   import java.util.*;
11   import java.util.concurrent.*;
12 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
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());
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 24 | Line 41 | public class PriorityBlockingQueueTest e
41      /** Sample Comparator */
42      static class MyReverseComparator implements Comparator {
43          public int compare(Object x, Object y) {
44 <            int i = ((Integer)x).intValue();
28 <            int j = ((Integer)y).intValue();
29 <            if (i < j) return 1;
30 <            if (i > j) return -1;
31 <            return 0;
44 >            return ((Comparable)y).compareTo(x);
45          }
46      }
47  
# Line 36 | 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 57 | Line 71 | public class PriorityBlockingQueueTest e
71      }
72  
73      /**
74 <     * Constructor throws IAE if  capacity argument nonpositive
74 >     * Constructor throws IAE if capacity argument nonpositive
75       */
76      public void testConstructor2() {
77          try {
# Line 248 | 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 327 | Line 342 | public class PriorityBlockingQueueTest e
342       */
343      public void testTimedOffer() throws InterruptedException {
344          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
345 <        Thread t = new Thread(new Runnable() {
346 <                public void run() {
347 <                    try {
348 <                        q.put(new Integer(0));
349 <                        q.put(new Integer(0));
350 <                        threadAssertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
351 <                        threadAssertTrue(q.offer(new Integer(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
337 <                    } finally { }
338 <                }
339 <            });
345 >        Thread t = new Thread(new CheckedRunnable() {
346 >            public void realRun() {
347 >                q.put(new Integer(0));
348 >                q.put(new Integer(0));
349 >                assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
350 >                assertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS));
351 >            }});
352  
353          t.start();
354          Thread.sleep(SMALL_DELAY_MS);
# Line 350 | Line 362 | public class PriorityBlockingQueueTest e
362      public void testTake() throws InterruptedException {
363          PriorityBlockingQueue q = populatedQueue(SIZE);
364          for (int i = 0; i < SIZE; ++i) {
365 <            assertEquals(i, ((Integer)q.take()).intValue());
365 >            assertEquals(i, q.take());
366          }
367      }
368  
369      /**
358 –     * take blocks interruptibly when empty
359 –     */
360 –    public void testTakeFromEmpty() throws InterruptedException {
361 –        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
362 –        Thread t = new Thread(new CheckedInterruptedRunnable() {
363 –            public void realRun() throws InterruptedException {
364 –                q.take();
365 –            }});
366 –
367 –        t.start();
368 –        Thread.sleep(SHORT_DELAY_MS);
369 –        t.interrupt();
370 –        t.join();
371 –    }
372 –
373 –    /**
370       * Take removes existing elements until empty, then blocks interruptibly
371       */
372      public void testBlockingTake() throws InterruptedException {
373 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
373 >        final PriorityBlockingQueue q = populatedQueue(SIZE);
374 >        Thread t = new Thread(new CheckedRunnable() {
375              public void realRun() throws InterruptedException {
379 –                PriorityBlockingQueue q = populatedQueue(SIZE);
376                  for (int i = 0; i < SIZE; ++i) {
377 <                    threadAssertEquals(i, ((Integer)q.take()).intValue());
377 >                    assertEquals(i, q.take());
378                  }
379 <                q.take();
379 >                try {
380 >                    q.take();
381 >                    shouldThrow();
382 >                } catch (InterruptedException success) {}
383              }});
384  
385          t.start();
# Line 396 | Line 395 | public class PriorityBlockingQueueTest e
395      public void testPoll() {
396          PriorityBlockingQueue q = populatedQueue(SIZE);
397          for (int i = 0; i < SIZE; ++i) {
398 <            assertEquals(i, ((Integer)q.poll()).intValue());
398 >            assertEquals(i, q.poll());
399          }
400          assertNull(q.poll());
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);
408          for (int i = 0; i < SIZE; ++i) {
409 <            assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
409 >            assertEquals(i, q.poll(0, MILLISECONDS));
410          }
411 <        assertNull(q.poll(0, TimeUnit.MILLISECONDS));
411 >        assertNull(q.poll(0, MILLISECONDS));
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);
419          for (int i = 0; i < SIZE; ++i) {
420 <            assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
420 >            assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
421          }
422 <        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
422 >        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
423      }
424  
425      /**
# Line 428 | Line 427 | public class PriorityBlockingQueueTest e
427       * returning timeout status
428       */
429      public void testInterruptedTimedPoll() throws InterruptedException {
430 <        Thread t = new Thread(new CheckedRunnable() {
430 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
431 >        final CountDownLatch aboutToWait = new CountDownLatch(1);
432 >        Thread t = newStartedThread(new CheckedRunnable() {
433              public void realRun() throws InterruptedException {
433 –                PriorityBlockingQueue q = populatedQueue(SIZE);
434                  for (int i = 0; i < SIZE; ++i) {
435 <                    threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
435 >                    long t0 = System.nanoTime();
436 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
437 >                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
438                  }
439 +                long t0 = System.nanoTime();
440 +                aboutToWait.countDown();
441                  try {
442 <                    q.poll(SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
443 <                    threadShouldThrow();
444 <                } catch (InterruptedException success) {}
445 <            }});
446 <
443 <        t.start();
444 <        Thread.sleep(SHORT_DELAY_MS);
445 <        t.interrupt();
446 <        t.join();
447 <    }
448 <
449 <    /**
450 <     *  timed poll before a delayed offer fails; after offer succeeds;
451 <     *  on interruption throws
452 <     */
453 <    public void testTimedPollWithOffer() throws InterruptedException {
454 <        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
455 <        Thread t = new Thread(new CheckedRunnable() {
456 <            public void realRun() throws InterruptedException {
457 <                threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
458 <                threadAssertEquals(0, q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
459 <                try {
460 <                    q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
461 <                    threadShouldThrow();
462 <                } catch (InterruptedException success) {}
442 >                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
443 >                    shouldThrow();
444 >                } catch (InterruptedException success) {
445 >                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
446 >                }
447              }});
448  
449 <        t.start();
450 <        Thread.sleep(SMALL_DELAY_MS);
467 <        assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
449 >        aboutToWait.await();
450 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
451          t.interrupt();
452 <        t.join();
452 >        awaitTermination(t, MEDIUM_DELAY_MS);
453      }
454  
472 –
455      /**
456       * peek returns next element, or null if empty
457       */
458      public void testPeek() {
459          PriorityBlockingQueue q = populatedQueue(SIZE);
460          for (int i = 0; i < SIZE; ++i) {
461 <            assertEquals(i, ((Integer)q.peek()).intValue());
462 <            q.poll();
461 >            assertEquals(i, q.peek());
462 >            assertEquals(i, q.poll());
463              assertTrue(q.peek() == null ||
464 <                       i != ((Integer)q.peek()).intValue());
464 >                       !q.peek().equals(i));
465          }
466          assertNull(q.peek());
467      }
# Line 490 | Line 472 | public class PriorityBlockingQueueTest e
472      public void testElement() {
473          PriorityBlockingQueue q = populatedQueue(SIZE);
474          for (int i = 0; i < SIZE; ++i) {
475 <            assertEquals(i, ((Integer)q.element()).intValue());
476 <            q.poll();
475 >            assertEquals(i, q.element());
476 >            assertEquals(i, q.poll());
477          }
478          try {
479              q.element();
# Line 505 | Line 487 | public class PriorityBlockingQueueTest e
487      public void testRemove() {
488          PriorityBlockingQueue q = populatedQueue(SIZE);
489          for (int i = 0; i < SIZE; ++i) {
490 <            assertEquals(i, ((Integer)q.remove()).intValue());
490 >            assertEquals(i, q.remove());
491          }
492          try {
493              q.remove();
# Line 519 | Line 501 | public class PriorityBlockingQueueTest e
501      public void testRemoveElement() {
502          PriorityBlockingQueue q = populatedQueue(SIZE);
503          for (int i = 1; i < SIZE; i+=2) {
504 <            assertTrue(q.remove(new Integer(i)));
504 >            assertTrue(q.contains(i));
505 >            assertTrue(q.remove(i));
506 >            assertFalse(q.contains(i));
507 >            assertTrue(q.contains(i-1));
508          }
509          for (int i = 0; i < SIZE; i+=2) {
510 <            assertTrue(q.remove(new Integer(i)));
511 <            assertFalse(q.remove(new Integer(i+1)));
510 >            assertTrue(q.contains(i));
511 >            assertTrue(q.remove(i));
512 >            assertFalse(q.contains(i));
513 >            assertFalse(q.remove(i+1));
514 >            assertFalse(q.contains(i+1));
515          }
516          assertTrue(q.isEmpty());
517      }
# Line 605 | Line 593 | public class PriorityBlockingQueueTest e
593      }
594  
595      /**
596 <     *  toArray contains all elements
596 >     * toArray contains all elements
597       */
598      public void testToArray() throws InterruptedException {
599          PriorityBlockingQueue q = populatedQueue(SIZE);
600          Object[] o = q.toArray();
601          Arrays.sort(o);
602          for (int i = 0; i < o.length; i++)
603 <            assertEquals(o[i], q.take());
603 >            assertSame(o[i], q.take());
604      }
605  
606      /**
607       * toArray(a) contains all elements
608       */
609      public void testToArray2() throws InterruptedException {
610 <        PriorityBlockingQueue q = populatedQueue(SIZE);
610 >        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
611          Integer[] ints = new Integer[SIZE];
612 <        ints = (Integer[])q.toArray(ints);
612 >        Integer[] array = q.toArray(ints);
613 >        assertSame(ints, array);
614          Arrays.sort(ints);
615          for (int i = 0; i < ints.length; i++)
616 <            assertEquals(ints[i], q.take());
616 >            assertSame(ints[i], q.take());
617      }
618  
619      /**
620 <     * toArray(null) throws NPE
620 >     * toArray(null) throws NullPointerException
621       */
622 <    public void testToArray_BadArg() {
622 >    public void testToArray_NullArg() {
623 >        PriorityBlockingQueue q = populatedQueue(SIZE);
624          try {
625 <            PriorityBlockingQueue q = populatedQueue(SIZE);
636 <            Object o[] = q.toArray(null);
625 >            q.toArray(null);
626              shouldThrow();
627          } catch (NullPointerException success) {}
628      }
629  
630      /**
631 <     * toArray with incompatible array type throws CCE
631 >     * toArray(incompatible array type) throws ArrayStoreException
632       */
633      public void testToArray1_BadArg() {
634 +        PriorityBlockingQueue q = populatedQueue(SIZE);
635          try {
636 <            PriorityBlockingQueue q = populatedQueue(SIZE);
647 <            Object o[] = q.toArray(new String[10] );
636 >            q.toArray(new String[10]);
637              shouldThrow();
638 <        } catch (ArrayStoreException  success) {}
638 >        } catch (ArrayStoreException success) {}
639      }
640  
641      /**
# Line 666 | Line 655 | public class PriorityBlockingQueueTest e
655      /**
656       * iterator.remove removes current element
657       */
658 <    public void testIteratorRemove () {
658 >    public void testIteratorRemove() {
659          final PriorityBlockingQueue q = new PriorityBlockingQueue(3);
660          q.add(new Integer(2));
661          q.add(new Integer(1));
# Line 702 | Line 691 | public class PriorityBlockingQueueTest e
691          ExecutorService executor = Executors.newFixedThreadPool(2);
692          executor.execute(new CheckedRunnable() {
693              public void realRun() throws InterruptedException {
694 <                threadAssertNull(q.poll());
695 <                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
696 <                threadAssertTrue(q.isEmpty());
694 >                assertNull(q.poll());
695 >                assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
696 >                assertTrue(q.isEmpty());
697              }});
698  
699          executor.execute(new CheckedRunnable() {
700              public void realRun() throws InterruptedException {
701                  Thread.sleep(SMALL_DELAY_MS);
702 <                q.put(new Integer(1));
702 >                q.put(one);
703              }});
704  
705          joinPool(executor);
# Line 823 | Line 812 | public class PriorityBlockingQueueTest e
812      }
813  
814      /**
815 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
815 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
816       */
817      public void testDrainToN() {
818          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
# Line 832 | Line 821 | public class PriorityBlockingQueueTest e
821                  assertTrue(q.offer(new Integer(j)));
822              ArrayList l = new ArrayList();
823              q.drainTo(l, i);
824 <            int k = (i < SIZE)? i : SIZE;
824 >            int k = (i < SIZE) ? i : SIZE;
825              assertEquals(l.size(), k);
826              assertEquals(q.size(), SIZE-k);
827              for (int j = 0; j < k; ++j)

Diff Legend

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