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.50 by jsr166, Tue Feb 21 01:54:04 2012 UTC vs.
Revision 1.68 by jsr166, Sat Aug 6 17:02:49 2016 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.Arrays;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 >
11   import java.util.ArrayList;
12 + import java.util.Arrays;
13   import java.util.Collection;
14   import java.util.Comparator;
15   import java.util.Iterator;
16   import java.util.NoSuchElementException;
17   import java.util.Queue;
17 – import java.util.concurrent.PriorityBlockingQueue;
18   import java.util.concurrent.BlockingQueue;
19   import java.util.concurrent.CountDownLatch;
20   import java.util.concurrent.Executors;
21   import java.util.concurrent.ExecutorService;
22 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
22 > import java.util.concurrent.PriorityBlockingQueue;
23 >
24 > import junit.framework.Test;
25  
26   public class PriorityBlockingQueueTest extends JSR166TestCase {
27  
# Line 36 | Line 38 | public class PriorityBlockingQueueTest e
38      }
39  
40      public static void main(String[] args) {
41 <        junit.textui.TestRunner.run(suite());
41 >        main(suite(), args);
42      }
43  
44      public static Test suite() {
# Line 45 | Line 47 | public class PriorityBlockingQueueTest e
47                              new InitialCapacity().testSuite());
48      }
49  
48 –    private static final int NOCAP = Integer.MAX_VALUE;
49 –
50      /** Sample Comparator */
51      static class MyReverseComparator implements Comparator {
52          public int compare(Object x, Object y) {
# Line 55 | Line 55 | public class PriorityBlockingQueueTest e
55      }
56  
57      /**
58 <     * Creates a queue of given size containing consecutive
58 >     * Returns a new queue of given size containing consecutive
59       * Integers 0 ... n.
60       */
61      private PriorityBlockingQueue<Integer> populatedQueue(int n) {
62          PriorityBlockingQueue<Integer> q =
63              new PriorityBlockingQueue<Integer>(n);
64          assertTrue(q.isEmpty());
65 <        for (int i = n-1; i >= 0; i-=2)
65 >        for (int i = n - 1; i >= 0; i -= 2)
66              assertTrue(q.offer(new Integer(i)));
67 <        for (int i = (n & 1); i < n; i+=2)
67 >        for (int i = (n & 1); i < n; i += 2)
68              assertTrue(q.offer(new Integer(i)));
69          assertFalse(q.isEmpty());
70 <        assertEquals(NOCAP, q.remainingCapacity());
70 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
71          assertEquals(n, q.size());
72          return q;
73      }
# Line 76 | Line 76 | public class PriorityBlockingQueueTest e
76       * A new queue has unbounded capacity
77       */
78      public void testConstructor1() {
79 <        assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
79 >        assertEquals(Integer.MAX_VALUE,
80 >                     new PriorityBlockingQueue(SIZE).remainingCapacity());
81      }
82  
83      /**
# Line 115 | Line 116 | public class PriorityBlockingQueueTest e
116       */
117      public void testConstructor5() {
118          Integer[] ints = new Integer[SIZE];
119 <        for (int i = 0; i < SIZE-1; ++i)
119 >        for (int i = 0; i < SIZE - 1; ++i)
120              ints[i] = i;
121          Collection<Integer> elements = Arrays.asList(ints);
122          try {
# Line 147 | Line 148 | public class PriorityBlockingQueueTest e
148          for (int i = 0; i < SIZE; ++i)
149              ints[i] = new Integer(i);
150          q.addAll(Arrays.asList(ints));
151 <        for (int i = SIZE-1; i >= 0; --i)
151 >        for (int i = SIZE - 1; i >= 0; --i)
152              assertEquals(ints[i], q.poll());
153      }
154  
# Line 157 | Line 158 | public class PriorityBlockingQueueTest e
158      public void testEmpty() {
159          PriorityBlockingQueue q = new PriorityBlockingQueue(2);
160          assertTrue(q.isEmpty());
161 <        assertEquals(NOCAP, q.remainingCapacity());
161 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
162          q.add(one);
163          assertFalse(q.isEmpty());
164          q.add(two);
# Line 167 | Line 168 | public class PriorityBlockingQueueTest e
168      }
169  
170      /**
171 <     * remainingCapacity does not change when elements added or removed,
171 <     * but size does
171 >     * remainingCapacity() always returns Integer.MAX_VALUE
172       */
173      public void testRemainingCapacity() {
174 <        PriorityBlockingQueue q = populatedQueue(SIZE);
174 >        BlockingQueue q = populatedQueue(SIZE);
175          for (int i = 0; i < SIZE; ++i) {
176 <            assertEquals(NOCAP, q.remainingCapacity());
177 <            assertEquals(SIZE-i, q.size());
178 <            q.remove();
176 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
177 >            assertEquals(SIZE - i, q.size());
178 >            assertEquals(i, q.remove());
179          }
180          for (int i = 0; i < SIZE; ++i) {
181 <            assertEquals(NOCAP, q.remainingCapacity());
181 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
182              assertEquals(i, q.size());
183 <            q.add(new Integer(i));
183 >            assertTrue(q.add(i));
184          }
185      }
186  
# Line 197 | Line 197 | public class PriorityBlockingQueueTest e
197       * Offer of non-Comparable throws CCE
198       */
199      public void testOfferNonComparable() {
200 +        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
201          try {
201 –            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
202 –            q.offer(new Object());
203 –            q.offer(new Object());
202              q.offer(new Object());
203              shouldThrow();
204 <        } catch (ClassCastException success) {}
204 >        } catch (ClassCastException success) {
205 >            assertTrue(q.isEmpty());
206 >            assertEquals(0, q.size());
207 >            assertNull(q.poll());
208 >        }
209      }
210  
211      /**
# Line 221 | Line 223 | public class PriorityBlockingQueueTest e
223       * addAll(this) throws IAE
224       */
225      public void testAddAllSelf() {
226 +        PriorityBlockingQueue q = populatedQueue(SIZE);
227          try {
225 –            PriorityBlockingQueue q = populatedQueue(SIZE);
228              q.addAll(q);
229              shouldThrow();
230          } catch (IllegalArgumentException success) {}
# Line 233 | Line 235 | public class PriorityBlockingQueueTest e
235       * possibly adding some elements
236       */
237      public void testAddAll3() {
238 +        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
239 +        Integer[] ints = new Integer[SIZE];
240 +        for (int i = 0; i < SIZE - 1; ++i)
241 +            ints[i] = new Integer(i);
242          try {
237 –            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
238 –            Integer[] ints = new Integer[SIZE];
239 –            for (int i = 0; i < SIZE-1; ++i)
240 –                ints[i] = new Integer(i);
243              q.addAll(Arrays.asList(ints));
244              shouldThrow();
245          } catch (NullPointerException success) {}
# Line 249 | Line 251 | public class PriorityBlockingQueueTest e
251      public void testAddAll5() {
252          Integer[] empty = new Integer[0];
253          Integer[] ints = new Integer[SIZE];
254 <        for (int i = SIZE-1; i >= 0; --i)
254 >        for (int i = SIZE - 1; i >= 0; --i)
255              ints[i] = new Integer(i);
256          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
257          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 264 | Line 266 | public class PriorityBlockingQueueTest e
266      public void testPut() {
267          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
268          for (int i = 0; i < SIZE; ++i) {
269 <            Integer I = new Integer(i);
270 <            q.put(I);
271 <            assertTrue(q.contains(I));
269 >            Integer x = new Integer(i);
270 >            q.put(x);
271 >            assertTrue(q.contains(x));
272          }
273          assertEquals(SIZE, q.size());
274      }
# Line 394 | Line 396 | public class PriorityBlockingQueueTest e
396          final CountDownLatch aboutToWait = new CountDownLatch(1);
397          Thread t = newStartedThread(new CheckedRunnable() {
398              public void realRun() throws InterruptedException {
399 +                long startTime = System.nanoTime();
400                  for (int i = 0; i < SIZE; ++i) {
398 –                    long t0 = System.nanoTime();
401                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
400 –                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
402                  }
402 –                long t0 = System.nanoTime();
403                  aboutToWait.countDown();
404                  try {
405                      q.poll(LONG_DELAY_MS, MILLISECONDS);
406                      shouldThrow();
407                  } catch (InterruptedException success) {
408 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
408 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
409                  }
410              }});
411  
412          aboutToWait.await();
413 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
413 >        waitForThreadToEnterWaitState(t);
414          t.interrupt();
415 <        awaitTermination(t, MEDIUM_DELAY_MS);
415 >        awaitTermination(t);
416      }
417  
418      /**
# Line 513 | Line 513 | public class PriorityBlockingQueueTest e
513                  assertTrue(changed);
514  
515              assertTrue(q.containsAll(p));
516 <            assertEquals(SIZE-i, q.size());
516 >            assertEquals(SIZE - i, q.size());
517              p.remove();
518          }
519      }
# Line 526 | Line 526 | public class PriorityBlockingQueueTest e
526              PriorityBlockingQueue q = populatedQueue(SIZE);
527              PriorityBlockingQueue p = populatedQueue(i);
528              assertTrue(q.removeAll(p));
529 <            assertEquals(SIZE-i, q.size());
529 >            assertEquals(SIZE - i, q.size());
530              for (int j = 0; j < i; ++j) {
531 <                Integer I = (Integer)(p.remove());
532 <                assertFalse(q.contains(I));
531 >                Integer x = (Integer)(p.remove());
532 >                assertFalse(q.contains(x));
533              }
534          }
535      }
# Line 574 | Line 574 | public class PriorityBlockingQueueTest e
574       */
575      public void testIterator() {
576          PriorityBlockingQueue q = populatedQueue(SIZE);
577 –        int i = 0;
577          Iterator it = q.iterator();
578 <        while (it.hasNext()) {
578 >        int i;
579 >        for (i = 0; it.hasNext(); i++)
580              assertTrue(q.contains(it.next()));
581 –            ++i;
582 –        }
581          assertEquals(i, SIZE);
582 +        assertIteratorExhausted(it);
583 +    }
584 +
585 +    /**
586 +     * iterator of empty collection has no elements
587 +     */
588 +    public void testEmptyIterator() {
589 +        assertIteratorExhausted(new PriorityBlockingQueue().iterator());
590      }
591  
592      /**
# Line 619 | Line 625 | public class PriorityBlockingQueueTest e
625      public void testPollInExecutor() {
626          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
627          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
628 <        ExecutorService executor = Executors.newFixedThreadPool(2);
629 <        executor.execute(new CheckedRunnable() {
630 <            public void realRun() throws InterruptedException {
631 <                assertNull(q.poll());
632 <                threadsStarted.await();
633 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
634 <                checkEmpty(q);
635 <            }});
636 <
637 <        executor.execute(new CheckedRunnable() {
638 <            public void realRun() throws InterruptedException {
639 <                threadsStarted.await();
640 <                q.put(one);
641 <            }});
642 <
643 <        joinPool(executor);
628 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
629 >        try (PoolCleaner cleaner = cleaner(executor)) {
630 >            executor.execute(new CheckedRunnable() {
631 >                public void realRun() throws InterruptedException {
632 >                    assertNull(q.poll());
633 >                    threadsStarted.await();
634 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
635 >                    checkEmpty(q);
636 >                }});
637 >
638 >            executor.execute(new CheckedRunnable() {
639 >                public void realRun() throws InterruptedException {
640 >                    threadsStarted.await();
641 >                    q.put(one);
642 >                }});
643 >        }
644      }
645  
646      /**
# Line 644 | Line 650 | public class PriorityBlockingQueueTest e
650          Queue x = populatedQueue(SIZE);
651          Queue y = serialClone(x);
652  
653 <        assertTrue(x != y);
653 >        assertNotSame(x, y);
654          assertEquals(x.size(), y.size());
655          while (!x.isEmpty()) {
656              assertFalse(y.isEmpty());
# Line 684 | Line 690 | public class PriorityBlockingQueueTest e
690          final PriorityBlockingQueue q = populatedQueue(SIZE);
691          Thread t = new Thread(new CheckedRunnable() {
692              public void realRun() {
693 <                q.put(new Integer(SIZE+1));
693 >                q.put(new Integer(SIZE + 1));
694              }});
695  
696          t.start();
# Line 701 | Line 707 | public class PriorityBlockingQueueTest e
707       * drainTo(c, n) empties first min(n, size) elements of queue into c
708       */
709      public void testDrainToN() {
710 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
710 >        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
711          for (int i = 0; i < SIZE + 2; ++i) {
712              for (int j = 0; j < SIZE; j++)
713                  assertTrue(q.offer(new Integer(j)));
# Line 709 | Line 715 | public class PriorityBlockingQueueTest e
715              q.drainTo(l, i);
716              int k = (i < SIZE) ? i : SIZE;
717              assertEquals(k, l.size());
718 <            assertEquals(SIZE-k, q.size());
718 >            assertEquals(SIZE - k, q.size());
719              for (int j = 0; j < k; ++j)
720                  assertEquals(l.get(j), new Integer(j));
721 <            while (q.poll() != null) ;
721 >            do {} while (q.poll() != null);
722 >        }
723 >    }
724 >
725 >    /**
726 >     * remove(null), contains(null) always return false
727 >     */
728 >    public void testNeverContainsNull() {
729 >        Collection<?>[] qs = {
730 >            new PriorityBlockingQueue<Object>(),
731 >            populatedQueue(2),
732 >        };
733 >
734 >        for (Collection<?> q : qs) {
735 >            assertFalse(q.contains(null));
736 >            assertFalse(q.remove(null));
737          }
738      }
739  

Diff Legend

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