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.48 by jsr166, Sat Nov 26 05:19:17 2011 UTC vs.
Revision 1.60 by jsr166, Sat Feb 28 20:13:46 2015 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 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 <     * Create 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 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());
202              q.offer(new Object());
203              q.offer(new Object());
204              shouldThrow();
# Line 264 | Line 263 | public class PriorityBlockingQueueTest e
263      public void testPut() {
264          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
265          for (int i = 0; i < SIZE; ++i) {
266 <            Integer I = new Integer(i);
267 <            q.put(I);
268 <            assertTrue(q.contains(I));
266 >            Integer x = new Integer(i);
267 >            q.put(x);
268 >            assertTrue(q.contains(x));
269          }
270          assertEquals(SIZE, q.size());
271      }
# Line 528 | Line 527 | public class PriorityBlockingQueueTest e
527              assertTrue(q.removeAll(p));
528              assertEquals(SIZE-i, q.size());
529              for (int j = 0; j < i; ++j) {
530 <                Integer I = (Integer)(p.remove());
531 <                assertFalse(q.contains(I));
530 >                Integer x = (Integer)(p.remove());
531 >                assertFalse(q.contains(x));
532              }
533          }
534      }
# Line 574 | Line 573 | public class PriorityBlockingQueueTest e
573       */
574      public void testIterator() {
575          PriorityBlockingQueue q = populatedQueue(SIZE);
577 –        int i = 0;
576          Iterator it = q.iterator();
577 <        while (it.hasNext()) {
577 >        int i;
578 >        for (i = 0; it.hasNext(); i++)
579              assertTrue(q.contains(it.next()));
581 –            ++i;
582 –        }
580          assertEquals(i, SIZE);
581 +        assertIteratorExhausted(it);
582 +    }
583 +
584 +    /**
585 +     * iterator of empty collection has no elements
586 +     */
587 +    public void testEmptyIterator() {
588 +        assertIteratorExhausted(new PriorityBlockingQueue().iterator());
589      }
590  
591      /**
# Line 644 | Line 649 | public class PriorityBlockingQueueTest e
649          Queue x = populatedQueue(SIZE);
650          Queue y = serialClone(x);
651  
652 <        assertTrue(x != y);
652 >        assertNotSame(x, y);
653          assertEquals(x.size(), y.size());
654          while (!x.isEmpty()) {
655              assertFalse(y.isEmpty());
# Line 708 | Line 713 | public class PriorityBlockingQueueTest e
713              ArrayList l = new ArrayList();
714              q.drainTo(l, i);
715              int k = (i < SIZE) ? i : SIZE;
716 <            assertEquals(l.size(), k);
717 <            assertEquals(q.size(), SIZE-k);
716 >            assertEquals(k, l.size());
717 >            assertEquals(SIZE-k, q.size());
718              for (int j = 0; j < k; ++j)
719                  assertEquals(l.get(j), new Integer(j));
720 <            while (q.poll() != null) ;
720 >            do {} while (q.poll() != null);
721 >        }
722 >    }
723 >
724 >    /**
725 >     * remove(null), contains(null) always return false
726 >     */
727 >    public void testNeverContainsNull() {
728 >        Collection<?>[] qs = {
729 >            new PriorityBlockingQueue<Object>(),
730 >            populatedQueue(2),
731 >        };
732 >
733 >        for (Collection<?> q : qs) {
734 >            assertFalse(q.contains(null));
735 >            assertFalse(q.remove(null));
736          }
737      }
738  

Diff Legend

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