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.81 by jsr166, Mon May 28 21:19:50 2018 UTC

# Line 20 | Line 20 | import java.util.concurrent.CountDownLat
20   import java.util.concurrent.Executors;
21   import java.util.concurrent.ExecutorService;
22   import java.util.concurrent.PriorityBlockingQueue;
23 + import java.util.concurrent.ThreadLocalRandom;
24  
25   import junit.framework.Test;
26  
# Line 33 | Line 34 | public class PriorityBlockingQueueTest e
34  
35      public static class InitialCapacity extends BlockingQueueTest {
36          protected BlockingQueue emptyCollection() {
37 <            return new PriorityBlockingQueue(SIZE);
37 >            ThreadLocalRandom rnd = ThreadLocalRandom.current();
38 >            int initialCapacity = rnd.nextInt(1, SIZE);
39 >            return new PriorityBlockingQueue(initialCapacity);
40          }
41      }
42  
# Line 42 | Line 45 | public class PriorityBlockingQueueTest e
45      }
46  
47      public static Test suite() {
48 <        return newTestSuite(PriorityBlockingQueueTest.class,
49 <                            new Generic().testSuite(),
50 <                            new InitialCapacity().testSuite());
48 >        class Implementation implements CollectionImplementation {
49 >            public Class<?> klazz() { return PriorityBlockingQueue.class; }
50 >            public Collection emptyCollection() {
51 >                return new PriorityBlockingQueue();
52 >            }
53 >            public Object makeElement(int i) { return i; }
54 >            public boolean isConcurrent() { return true; }
55 >            public boolean permitsNulls() { return false; }
56 >        }
57 >        class ComparatorImplementation implements CollectionImplementation {
58 >            public Class<?> klazz() { return PriorityBlockingQueue.class; }
59 >            public Collection emptyCollection() {
60 >                ThreadLocalRandom rnd = ThreadLocalRandom.current();
61 >                int initialCapacity = rnd.nextInt(1, 10);
62 >                return new PriorityBlockingQueue(
63 >                    initialCapacity, new MyReverseComparator());
64 >            }
65 >            public Object makeElement(int i) { return i; }
66 >            public boolean isConcurrent() { return true; }
67 >            public boolean permitsNulls() { return false; }
68 >        }
69 >        return newTestSuite(
70 >            PriorityBlockingQueueTest.class,
71 >            new Generic().testSuite(),
72 >            new InitialCapacity().testSuite(),
73 >            CollectionTest.testSuite(new Implementation()),
74 >            CollectionTest.testSuite(new ComparatorImplementation()));
75      }
76  
77      /** Sample Comparator */
78 <    static class MyReverseComparator implements Comparator {
78 >    static class MyReverseComparator implements Comparator, java.io.Serializable {
79          public int compare(Object x, Object y) {
80              return ((Comparable)y).compareTo(x);
81          }
# Line 56 | Line 83 | public class PriorityBlockingQueueTest e
83  
84      /**
85       * Returns a new queue of given size containing consecutive
86 <     * Integers 0 ... n.
86 >     * Integers 0 ... n - 1.
87       */
88 <    private PriorityBlockingQueue<Integer> populatedQueue(int n) {
88 >    private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
89          PriorityBlockingQueue<Integer> q =
90              new PriorityBlockingQueue<Integer>(n);
91          assertTrue(q.isEmpty());
# Line 69 | Line 96 | public class PriorityBlockingQueueTest e
96          assertFalse(q.isEmpty());
97          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
98          assertEquals(n, q.size());
99 +        assertEquals((Integer) 0, q.peek());
100          return q;
101      }
102  
# Line 81 | Line 109 | public class PriorityBlockingQueueTest e
109      }
110  
111      /**
112 <     * Constructor throws IAE if capacity argument nonpositive
112 >     * Constructor throws IllegalArgumentException if capacity argument nonpositive
113       */
114      public void testConstructor2() {
115          try {
# Line 220 | Line 248 | public class PriorityBlockingQueueTest e
248      }
249  
250      /**
251 <     * addAll(this) throws IAE
251 >     * addAll(this) throws IllegalArgumentException
252       */
253      public void testAddAllSelf() {
254          PriorityBlockingQueue q = populatedQueue(SIZE);
# Line 293 | Line 321 | public class PriorityBlockingQueueTest e
321      /**
322       * timed offer does not time out
323       */
324 <    public void testTimedOffer() throws InterruptedException {
324 >    public void testTimedOffer() {
325          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
326          Thread t = newStartedThread(new CheckedRunnable() {
327              public void realRun() {
# Line 324 | Line 352 | public class PriorityBlockingQueueTest e
352          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
353          Thread t = newStartedThread(new CheckedRunnable() {
354              public void realRun() throws InterruptedException {
355 <                for (int i = 0; i < SIZE; ++i) {
328 <                    assertEquals(i, q.take());
329 <                }
355 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
356  
357                  Thread.currentThread().interrupt();
358                  try {
# Line 344 | Line 370 | public class PriorityBlockingQueueTest e
370              }});
371  
372          await(pleaseInterrupt);
373 <        assertThreadStaysAlive(t);
373 >        assertThreadBlocks(t, Thread.State.WAITING);
374          t.interrupt();
375          awaitTermination(t);
376      }
# Line 393 | Line 419 | public class PriorityBlockingQueueTest e
419       */
420      public void testInterruptedTimedPoll() throws InterruptedException {
421          final BlockingQueue<Integer> q = populatedQueue(SIZE);
422 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
422 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
423          Thread t = newStartedThread(new CheckedRunnable() {
424              public void realRun() throws InterruptedException {
425                  long startTime = System.nanoTime();
426 <                for (int i = 0; i < SIZE; ++i) {
426 >                for (int i = 0; i < SIZE; i++)
427                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
428 <                }
429 <                aboutToWait.countDown();
428 >
429 >                Thread.currentThread().interrupt();
430 >                try {
431 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
432 >                    shouldThrow();
433 >                } catch (InterruptedException success) {}
434 >                assertFalse(Thread.interrupted());
435 >
436 >                pleaseInterrupt.countDown();
437                  try {
438                      q.poll(LONG_DELAY_MS, MILLISECONDS);
439                      shouldThrow();
440 <                } catch (InterruptedException success) {
441 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
442 <                }
440 >                } catch (InterruptedException success) {}
441 >                assertFalse(Thread.interrupted());
442 >
443 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
444              }});
445  
446 <        aboutToWait.await();
447 <        waitForThreadToEnterWaitState(t);
446 >        await(pleaseInterrupt);
447 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
448          t.interrupt();
449          awaitTermination(t);
450      }
# Line 539 | Line 573 | public class PriorityBlockingQueueTest e
573       */
574      public void testToArray() throws InterruptedException {
575          PriorityBlockingQueue q = populatedQueue(SIZE);
576 <        Object[] o = q.toArray();
577 <        Arrays.sort(o);
578 <        for (int i = 0; i < o.length; i++)
579 <            assertSame(o[i], q.take());
576 >        Object[] a = q.toArray();
577 >        assertSame(Object[].class, a.getClass());
578 >        Arrays.sort(a);
579 >        for (Object o : a)
580 >            assertSame(o, q.take());
581 >        assertTrue(q.isEmpty());
582      }
583  
584      /**
# Line 554 | Line 590 | public class PriorityBlockingQueueTest e
590          Integer[] array = q.toArray(ints);
591          assertSame(ints, array);
592          Arrays.sort(ints);
593 <        for (int i = 0; i < ints.length; i++)
594 <            assertSame(ints[i], q.take());
593 >        for (Integer o : ints)
594 >            assertSame(o, q.take());
595 >        assertTrue(q.isEmpty());
596      }
597  
598      /**
# Line 644 | Line 681 | public class PriorityBlockingQueueTest e
681      }
682  
683      /**
684 <     * A deserialized serialized queue has same elements
684 >     * A deserialized/reserialized queue has same elements
685       */
686      public void testSerialization() throws Exception {
687          Queue x = populatedQueue(SIZE);

Diff Legend

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