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.31 by jsr166, Tue Oct 19 00:41:14 2010 UTC vs.
Revision 1.40 by jsr166, Sun Nov 28 08:43:53 2010 UTC

# Line 49 | 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 366 | Line 367 | public class PriorityBlockingQueueTest e
367      }
368  
369      /**
369 –     * take blocks interruptibly when empty
370 –     */
371 –    public void testTakeFromEmpty() throws InterruptedException {
372 –        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
373 –        Thread t = new Thread(new CheckedInterruptedRunnable() {
374 –            public void realRun() throws InterruptedException {
375 –                q.take();
376 –            }});
377 –
378 –        t.start();
379 –        Thread.sleep(SHORT_DELAY_MS);
380 –        t.interrupt();
381 –        t.join();
382 –    }
383 –
384 –    /**
370       * Take removes existing elements until empty, then blocks interruptibly
371       */
372      public void testBlockingTake() throws InterruptedException {
# Line 416 | 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 427 | 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 442 | 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 {
447 –                PriorityBlockingQueue q = populatedQueue(SIZE);
434                  for (int i = 0; i < SIZE; ++i) {
435 <                    assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
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, MILLISECONDS);
442 >                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
443                      shouldThrow();
444 <                } catch (InterruptedException success) {}
444 >                } catch (InterruptedException success) {
445 >                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
446 >                }
447              }});
448  
449 <        t.start();
450 <        Thread.sleep(SHORT_DELAY_MS);
449 >        aboutToWait.await();
450 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
451          t.interrupt();
452 <        t.join();
452 >        awaitTermination(t, MEDIUM_DELAY_MS);
453      }
454  
455      /**
# Line 509 | 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 602 | Line 600 | public class PriorityBlockingQueueTest e
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 <            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 <            Object o[] = q.toArray(new String[10]);
636 >            q.toArray(new String[10]);
637              shouldThrow();
638          } catch (ArrayStoreException success) {}
639      }
# Line 822 | 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