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.64 by jsr166, Sun May 24 01:42:14 2015 UTC vs.
Revision 1.72 by jsr166, Sat Mar 25 21:41:10 2017 UTC

# Line 42 | Line 42 | public class PriorityBlockingQueueTest e
42      }
43  
44      public static Test suite() {
45 +        class Implementation implements CollectionImplementation {
46 +            public Class<?> klazz() { return PriorityBlockingQueue.class; }
47 +            public Collection emptyCollection() { return new PriorityBlockingQueue(); }
48 +            public Object makeElement(int i) { return i; }
49 +            public boolean isConcurrent() { return true; }
50 +            public boolean permitsNulls() { return false; }
51 +        }
52          return newTestSuite(PriorityBlockingQueueTest.class,
53                              new Generic().testSuite(),
54 <                            new InitialCapacity().testSuite());
54 >                            new InitialCapacity().testSuite(),
55 >                            CollectionTest.testSuite(new Implementation()));
56      }
57  
58      /** Sample Comparator */
# Line 56 | Line 64 | public class PriorityBlockingQueueTest e
64  
65      /**
66       * Returns a new queue of given size containing consecutive
67 <     * Integers 0 ... n.
67 >     * Integers 0 ... n - 1.
68       */
69 <    private PriorityBlockingQueue<Integer> populatedQueue(int n) {
69 >    private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
70          PriorityBlockingQueue<Integer> q =
71              new PriorityBlockingQueue<Integer>(n);
72          assertTrue(q.isEmpty());
# Line 69 | Line 77 | public class PriorityBlockingQueueTest e
77          assertFalse(q.isEmpty());
78          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
79          assertEquals(n, q.size());
80 +        assertEquals((Integer) 0, q.peek());
81          return q;
82      }
83  
# Line 200 | Line 209 | public class PriorityBlockingQueueTest e
209          PriorityBlockingQueue q = new PriorityBlockingQueue(1);
210          try {
211              q.offer(new Object());
203 –            q.offer(new Object());
212              shouldThrow();
213 <        } catch (ClassCastException success) {}
213 >        } catch (ClassCastException success) {
214 >            assertTrue(q.isEmpty());
215 >            assertEquals(0, q.size());
216 >            assertNull(q.poll());
217 >        }
218      }
219  
220      /**
# Line 393 | Line 405 | public class PriorityBlockingQueueTest e
405          final CountDownLatch aboutToWait = new CountDownLatch(1);
406          Thread t = newStartedThread(new CheckedRunnable() {
407              public void realRun() throws InterruptedException {
408 +                long startTime = System.nanoTime();
409                  for (int i = 0; i < SIZE; ++i) {
397 –                    long t0 = System.nanoTime();
410                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
399 –                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
411                  }
401 –                long t0 = System.nanoTime();
412                  aboutToWait.countDown();
413                  try {
414                      q.poll(LONG_DELAY_MS, MILLISECONDS);
415                      shouldThrow();
416                  } catch (InterruptedException success) {
417 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
417 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
418                  }
419              }});
420  
421 <        aboutToWait.await();
422 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
421 >        await(aboutToWait);
422 >        waitForThreadToEnterWaitState(t);
423          t.interrupt();
424 <        awaitTermination(t, MEDIUM_DELAY_MS);
424 >        awaitTermination(t);
425      }
426  
427      /**
# Line 624 | Line 634 | public class PriorityBlockingQueueTest e
634      public void testPollInExecutor() {
635          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
636          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
637 <        ExecutorService executor = Executors.newFixedThreadPool(2);
638 <        executor.execute(new CheckedRunnable() {
639 <            public void realRun() throws InterruptedException {
640 <                assertNull(q.poll());
641 <                threadsStarted.await();
642 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
643 <                checkEmpty(q);
644 <            }});
645 <
646 <        executor.execute(new CheckedRunnable() {
647 <            public void realRun() throws InterruptedException {
648 <                threadsStarted.await();
649 <                q.put(one);
650 <            }});
651 <
652 <        joinPool(executor);
637 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
638 >        try (PoolCleaner cleaner = cleaner(executor)) {
639 >            executor.execute(new CheckedRunnable() {
640 >                public void realRun() throws InterruptedException {
641 >                    assertNull(q.poll());
642 >                    threadsStarted.await();
643 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
644 >                    checkEmpty(q);
645 >                }});
646 >
647 >            executor.execute(new CheckedRunnable() {
648 >                public void realRun() throws InterruptedException {
649 >                    threadsStarted.await();
650 >                    q.put(one);
651 >                }});
652 >        }
653      }
654  
655      /**

Diff Legend

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