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.68 by jsr166, Sat Aug 6 17:02:49 2016 UTC vs.
Revision 1.77 by jsr166, Sun May 14 04:14: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 293 | Line 302 | public class PriorityBlockingQueueTest e
302      /**
303       * timed offer does not time out
304       */
305 <    public void testTimedOffer() throws InterruptedException {
305 >    public void testTimedOffer() {
306          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
307          Thread t = newStartedThread(new CheckedRunnable() {
308              public void realRun() {
# Line 324 | Line 333 | public class PriorityBlockingQueueTest e
333          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
334          Thread t = newStartedThread(new CheckedRunnable() {
335              public void realRun() throws InterruptedException {
336 <                for (int i = 0; i < SIZE; ++i) {
328 <                    assertEquals(i, q.take());
329 <                }
336 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
337  
338                  Thread.currentThread().interrupt();
339                  try {
# Line 344 | Line 351 | public class PriorityBlockingQueueTest e
351              }});
352  
353          await(pleaseInterrupt);
354 <        assertThreadStaysAlive(t);
354 >        assertThreadBlocks(t, Thread.State.WAITING);
355          t.interrupt();
356          awaitTermination(t);
357      }
# Line 393 | Line 400 | public class PriorityBlockingQueueTest e
400       */
401      public void testInterruptedTimedPoll() throws InterruptedException {
402          final BlockingQueue<Integer> q = populatedQueue(SIZE);
403 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
403 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
404          Thread t = newStartedThread(new CheckedRunnable() {
405              public void realRun() throws InterruptedException {
406                  long startTime = System.nanoTime();
407 <                for (int i = 0; i < SIZE; ++i) {
407 >                for (int i = 0; i < SIZE; i++)
408                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
409 <                }
410 <                aboutToWait.countDown();
409 >
410 >                Thread.currentThread().interrupt();
411                  try {
412                      q.poll(LONG_DELAY_MS, MILLISECONDS);
413                      shouldThrow();
414 <                } catch (InterruptedException success) {
415 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
416 <                }
414 >                } catch (InterruptedException success) {}
415 >                assertFalse(Thread.interrupted());
416 >
417 >                pleaseInterrupt.countDown();
418 >                try {
419 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
420 >                    shouldThrow();
421 >                } catch (InterruptedException success) {}
422 >                assertFalse(Thread.interrupted());
423 >
424 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
425              }});
426  
427 <        aboutToWait.await();
428 <        waitForThreadToEnterWaitState(t);
427 >        await(pleaseInterrupt);
428 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
429          t.interrupt();
430          awaitTermination(t);
431      }

Diff Legend

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