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.62 by jsr166, Fri May 15 18:21:19 2015 UTC vs.
Revision 1.84 by jsr166, Thu Sep 5 21:11:13 2019 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());
92 <        for (int i = n-1; i >= 0; i -= 2)
92 >        for (int i = n - 1; i >= 0; i -= 2)
93              assertTrue(q.offer(new Integer(i)));
94          for (int i = (n & 1); i < n; i += 2)
95              assertTrue(q.offer(new Integer(i)));
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 116 | Line 144 | public class PriorityBlockingQueueTest e
144       */
145      public void testConstructor5() {
146          Integer[] ints = new Integer[SIZE];
147 <        for (int i = 0; i < SIZE-1; ++i)
147 >        for (int i = 0; i < SIZE - 1; ++i)
148              ints[i] = i;
149          Collection<Integer> elements = Arrays.asList(ints);
150          try {
# Line 148 | Line 176 | public class PriorityBlockingQueueTest e
176          for (int i = 0; i < SIZE; ++i)
177              ints[i] = new Integer(i);
178          q.addAll(Arrays.asList(ints));
179 <        for (int i = SIZE-1; i >= 0; --i)
179 >        for (int i = SIZE - 1; i >= 0; --i)
180              assertEquals(ints[i], q.poll());
181      }
182  
# Line 200 | Line 228 | public class PriorityBlockingQueueTest e
228          PriorityBlockingQueue q = new PriorityBlockingQueue(1);
229          try {
230              q.offer(new Object());
203 –            q.offer(new Object());
231              shouldThrow();
232 <        } catch (ClassCastException success) {}
232 >        } catch (ClassCastException success) {
233 >            assertTrue(q.isEmpty());
234 >            assertEquals(0, q.size());
235 >            assertNull(q.poll());
236 >        }
237      }
238  
239      /**
# Line 217 | 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 234 | Line 265 | public class PriorityBlockingQueueTest e
265      public void testAddAll3() {
266          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
267          Integer[] ints = new Integer[SIZE];
268 <        for (int i = 0; i < SIZE-1; ++i)
268 >        for (int i = 0; i < SIZE - 1; ++i)
269              ints[i] = new Integer(i);
270          try {
271              q.addAll(Arrays.asList(ints));
# Line 248 | Line 279 | public class PriorityBlockingQueueTest e
279      public void testAddAll5() {
280          Integer[] empty = new Integer[0];
281          Integer[] ints = new Integer[SIZE];
282 <        for (int i = SIZE-1; i >= 0; --i)
282 >        for (int i = SIZE - 1; i >= 0; --i)
283              ints[i] = new Integer(i);
284          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
285          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 288 | Line 319 | public class PriorityBlockingQueueTest e
319      }
320  
321      /**
322 <     * timed offer does not time out
322 >     * Queue is unbounded, so timed offer never times 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 321 | 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) {
325 <                    assertEquals(i, q.take());
326 <                }
355 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
356  
357                  Thread.currentThread().interrupt();
358                  try {
# Line 341 | Line 370 | public class PriorityBlockingQueueTest e
370              }});
371  
372          await(pleaseInterrupt);
373 <        assertThreadStaysAlive(t);
373 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
374          t.interrupt();
375          awaitTermination(t);
376      }
# Line 390 | 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 <                for (int i = 0; i < SIZE; ++i) {
397 <                    long t0 = System.nanoTime();
425 >                for (int i = 0; i < SIZE; i++)
426                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
427 <                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
428 <                }
401 <                long t0 = System.nanoTime();
402 <                aboutToWait.countDown();
427 >
428 >                Thread.currentThread().interrupt();
429                  try {
430 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
430 >                    q.poll(randomTimeout(), randomTimeUnit());
431                      shouldThrow();
432 <                } catch (InterruptedException success) {
433 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
434 <                }
432 >                } catch (InterruptedException success) {}
433 >                assertFalse(Thread.interrupted());
434 >
435 >                pleaseInterrupt.countDown();
436 >                try {
437 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
438 >                    shouldThrow();
439 >                } catch (InterruptedException success) {}
440 >                assertFalse(Thread.interrupted());
441              }});
442  
443 <        aboutToWait.await();
444 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
443 >        await(pleaseInterrupt);
444 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
445          t.interrupt();
446 <        awaitTermination(t, MEDIUM_DELAY_MS);
446 >        awaitTermination(t);
447      }
448  
449      /**
# Line 512 | Line 544 | public class PriorityBlockingQueueTest e
544                  assertTrue(changed);
545  
546              assertTrue(q.containsAll(p));
547 <            assertEquals(SIZE-i, q.size());
547 >            assertEquals(SIZE - i, q.size());
548              p.remove();
549          }
550      }
# Line 525 | Line 557 | public class PriorityBlockingQueueTest e
557              PriorityBlockingQueue q = populatedQueue(SIZE);
558              PriorityBlockingQueue p = populatedQueue(i);
559              assertTrue(q.removeAll(p));
560 <            assertEquals(SIZE-i, q.size());
560 >            assertEquals(SIZE - i, q.size());
561              for (int j = 0; j < i; ++j) {
562                  Integer x = (Integer)(p.remove());
563                  assertFalse(q.contains(x));
# Line 538 | Line 570 | public class PriorityBlockingQueueTest e
570       */
571      public void testToArray() throws InterruptedException {
572          PriorityBlockingQueue q = populatedQueue(SIZE);
573 <        Object[] o = q.toArray();
574 <        Arrays.sort(o);
575 <        for (int i = 0; i < o.length; i++)
576 <            assertSame(o[i], q.take());
573 >        Object[] a = q.toArray();
574 >        assertSame(Object[].class, a.getClass());
575 >        Arrays.sort(a);
576 >        for (Object o : a)
577 >            assertSame(o, q.take());
578 >        assertTrue(q.isEmpty());
579      }
580  
581      /**
# Line 553 | Line 587 | public class PriorityBlockingQueueTest e
587          Integer[] array = q.toArray(ints);
588          assertSame(ints, array);
589          Arrays.sort(ints);
590 <        for (int i = 0; i < ints.length; i++)
591 <            assertSame(ints[i], q.take());
590 >        for (Integer o : ints)
591 >            assertSame(o, q.take());
592 >        assertTrue(q.isEmpty());
593      }
594  
595      /**
# Line 624 | Line 659 | public class PriorityBlockingQueueTest e
659      public void testPollInExecutor() {
660          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
661          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
662 <        ExecutorService executor = Executors.newFixedThreadPool(2);
663 <        executor.execute(new CheckedRunnable() {
664 <            public void realRun() throws InterruptedException {
665 <                assertNull(q.poll());
666 <                threadsStarted.await();
667 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
668 <                checkEmpty(q);
669 <            }});
670 <
671 <        executor.execute(new CheckedRunnable() {
672 <            public void realRun() throws InterruptedException {
673 <                threadsStarted.await();
674 <                q.put(one);
675 <            }});
676 <
677 <        joinPool(executor);
662 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
663 >        try (PoolCleaner cleaner = cleaner(executor)) {
664 >            executor.execute(new CheckedRunnable() {
665 >                public void realRun() throws InterruptedException {
666 >                    assertNull(q.poll());
667 >                    threadsStarted.await();
668 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
669 >                    checkEmpty(q);
670 >                }});
671 >
672 >            executor.execute(new CheckedRunnable() {
673 >                public void realRun() throws InterruptedException {
674 >                    threadsStarted.await();
675 >                    q.put(one);
676 >                }});
677 >        }
678      }
679  
680      /**
681 <     * A deserialized serialized queue has same elements
681 >     * A deserialized/reserialized queue has same elements
682       */
683      public void testSerialization() throws Exception {
684          Queue x = populatedQueue(SIZE);
# Line 689 | Line 724 | public class PriorityBlockingQueueTest e
724          final PriorityBlockingQueue q = populatedQueue(SIZE);
725          Thread t = new Thread(new CheckedRunnable() {
726              public void realRun() {
727 <                q.put(new Integer(SIZE+1));
727 >                q.put(new Integer(SIZE + 1));
728              }});
729  
730          t.start();
# Line 706 | Line 741 | public class PriorityBlockingQueueTest e
741       * drainTo(c, n) empties first min(n, size) elements of queue into c
742       */
743      public void testDrainToN() {
744 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
744 >        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
745          for (int i = 0; i < SIZE + 2; ++i) {
746              for (int j = 0; j < SIZE; j++)
747                  assertTrue(q.offer(new Integer(j)));
# Line 714 | Line 749 | public class PriorityBlockingQueueTest e
749              q.drainTo(l, i);
750              int k = (i < SIZE) ? i : SIZE;
751              assertEquals(k, l.size());
752 <            assertEquals(SIZE-k, q.size());
752 >            assertEquals(SIZE - k, q.size());
753              for (int j = 0; j < k; ++j)
754                  assertEquals(l.get(j), new Integer(j));
755              do {} while (q.poll() != null);

Diff Legend

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