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.84 by jsr166, Thu Sep 5 21:11:13 2019 UTC vs.
Revision 1.85 by dl, Tue Jan 26 13:33:06 2021 UTC

# Line 50 | Line 50 | public class PriorityBlockingQueueTest e
50              public Collection emptyCollection() {
51                  return new PriorityBlockingQueue();
52              }
53 <            public Object makeElement(int i) { return i; }
53 >            public Object makeElement(int i) { return JSR166TestCase.itemFor(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 +            @SuppressWarnings("unchecked")
60              public Collection emptyCollection() {
61                  ThreadLocalRandom rnd = ThreadLocalRandom.current();
62                  int initialCapacity = rnd.nextInt(1, 10);
63                  return new PriorityBlockingQueue(
64                      initialCapacity, new MyReverseComparator());
65              }
66 <            public Object makeElement(int i) { return i; }
66 >            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
67              public boolean isConcurrent() { return true; }
68              public boolean permitsNulls() { return false; }
69          }
# Line 76 | Line 77 | public class PriorityBlockingQueueTest e
77  
78      /** Sample Comparator */
79      static class MyReverseComparator implements Comparator, java.io.Serializable {
80 +        @SuppressWarnings("unchecked")
81          public int compare(Object x, Object y) {
82              return ((Comparable)y).compareTo(x);
83          }
# Line 83 | Line 85 | public class PriorityBlockingQueueTest e
85  
86      /**
87       * Returns a new queue of given size containing consecutive
88 <     * Integers 0 ... n - 1.
88 >     * Items 0 ... n - 1.
89       */
90 <    private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
91 <        PriorityBlockingQueue<Integer> q =
92 <            new PriorityBlockingQueue<Integer>(n);
90 >    private static PriorityBlockingQueue<Item> populatedQueue(int n) {
91 >        PriorityBlockingQueue<Item> q =
92 >            new PriorityBlockingQueue<Item>(n);
93          assertTrue(q.isEmpty());
94          for (int i = n - 1; i >= 0; i -= 2)
95 <            assertTrue(q.offer(new Integer(i)));
95 >            mustOffer(q, i);
96          for (int i = (n & 1); i < n; i += 2)
97 <            assertTrue(q.offer(new Integer(i)));
97 >            mustOffer(q, i);
98          assertFalse(q.isEmpty());
99 <        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
100 <        assertEquals(n, q.size());
101 <        assertEquals((Integer) 0, q.peek());
99 >        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
100 >        mustEqual(n, q.size());
101 >        mustEqual(0, q.peek());
102          return q;
103      }
104  
# Line 104 | Line 106 | public class PriorityBlockingQueueTest e
106       * A new queue has unbounded capacity
107       */
108      public void testConstructor1() {
109 <        assertEquals(Integer.MAX_VALUE,
110 <                     new PriorityBlockingQueue(SIZE).remainingCapacity());
109 >        mustEqual(Integer.MAX_VALUE,
110 >                     new PriorityBlockingQueue<Item>(SIZE).remainingCapacity());
111      }
112  
113      /**
# Line 113 | Line 115 | public class PriorityBlockingQueueTest e
115       */
116      public void testConstructor2() {
117          try {
118 <            new PriorityBlockingQueue(0);
118 >            new PriorityBlockingQueue<Item>(0);
119              shouldThrow();
120          } catch (IllegalArgumentException success) {}
121      }
# Line 123 | Line 125 | public class PriorityBlockingQueueTest e
125       */
126      public void testConstructor3() {
127          try {
128 <            new PriorityBlockingQueue(null);
128 >            new PriorityBlockingQueue<Item>(null);
129              shouldThrow();
130          } catch (NullPointerException success) {}
131      }
# Line 132 | Line 134 | public class PriorityBlockingQueueTest e
134       * Initializing from Collection of null elements throws NPE
135       */
136      public void testConstructor4() {
137 <        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
137 >        Collection<Item> elements = Arrays.asList(new Item[SIZE]);
138          try {
139 <            new PriorityBlockingQueue(elements);
139 >            new PriorityBlockingQueue<Item>(elements);
140              shouldThrow();
141          } catch (NullPointerException success) {}
142      }
# Line 143 | Line 145 | public class PriorityBlockingQueueTest e
145       * Initializing from Collection with some null elements throws NPE
146       */
147      public void testConstructor5() {
148 <        Integer[] ints = new Integer[SIZE];
149 <        for (int i = 0; i < SIZE - 1; ++i)
148 <            ints[i] = i;
149 <        Collection<Integer> elements = Arrays.asList(ints);
148 >        Item[] items = new Item[2]; items[0] = zero;
149 >        Collection<Item> elements = Arrays.asList(items);
150          try {
151 <            new PriorityBlockingQueue(elements);
151 >            new PriorityBlockingQueue<Item>(elements);
152              shouldThrow();
153          } catch (NullPointerException success) {}
154      }
# Line 157 | Line 157 | public class PriorityBlockingQueueTest e
157       * Queue contains all elements of collection used to initialize
158       */
159      public void testConstructor6() {
160 <        Integer[] ints = new Integer[SIZE];
160 >        Item[] items = defaultItems;
161 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(Arrays.asList(items));
162          for (int i = 0; i < SIZE; ++i)
163 <            ints[i] = i;
163 <        PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
164 <        for (int i = 0; i < SIZE; ++i)
165 <            assertEquals(ints[i], q.poll());
163 >            mustEqual(items[i], q.poll());
164      }
165  
166      /**
# Line 170 | Line 168 | public class PriorityBlockingQueueTest e
168       */
169      public void testConstructor7() {
170          MyReverseComparator cmp = new MyReverseComparator();
171 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE, cmp);
172 <        assertEquals(cmp, q.comparator());
173 <        Integer[] ints = new Integer[SIZE];
174 <        for (int i = 0; i < SIZE; ++i)
175 <            ints[i] = new Integer(i);
178 <        q.addAll(Arrays.asList(ints));
171 >        @SuppressWarnings("unchecked")
172 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE, cmp);
173 >        mustEqual(cmp, q.comparator());
174 >        Item[] items = defaultItems;
175 >        q.addAll(Arrays.asList(items));
176          for (int i = SIZE - 1; i >= 0; --i)
177 <            assertEquals(ints[i], q.poll());
177 >            mustEqual(items[i], q.poll());
178      }
179  
180      /**
181       * isEmpty is true before add, false after
182       */
183      public void testEmpty() {
184 <        PriorityBlockingQueue q = new PriorityBlockingQueue(2);
184 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
185          assertTrue(q.isEmpty());
186 <        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
186 >        mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
187          q.add(one);
188          assertFalse(q.isEmpty());
189          q.add(two);
# Line 199 | Line 196 | public class PriorityBlockingQueueTest e
196       * remainingCapacity() always returns Integer.MAX_VALUE
197       */
198      public void testRemainingCapacity() {
199 <        BlockingQueue q = populatedQueue(SIZE);
199 >        BlockingQueue<Item> q = populatedQueue(SIZE);
200          for (int i = 0; i < SIZE; ++i) {
201 <            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
202 <            assertEquals(SIZE - i, q.size());
203 <            assertEquals(i, q.remove());
201 >            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
202 >            mustEqual(SIZE - i, q.size());
203 >            mustEqual(i, q.remove());
204          }
205          for (int i = 0; i < SIZE; ++i) {
206 <            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
207 <            assertEquals(i, q.size());
208 <            assertTrue(q.add(i));
206 >            mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
207 >            mustEqual(i, q.size());
208 >            mustAdd(q, i);
209          }
210      }
211  
# Line 216 | Line 213 | public class PriorityBlockingQueueTest e
213       * Offer of comparable element succeeds
214       */
215      public void testOffer() {
216 <        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
216 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(1);
217          assertTrue(q.offer(zero));
218          assertTrue(q.offer(one));
219      }
# Line 225 | Line 222 | public class PriorityBlockingQueueTest e
222       * Offer of non-Comparable throws CCE
223       */
224      public void testOfferNonComparable() {
225 <        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
225 >        PriorityBlockingQueue<Object> q = new PriorityBlockingQueue<Object>(1);
226          try {
227              q.offer(new Object());
228              shouldThrow();
229          } catch (ClassCastException success) {
230              assertTrue(q.isEmpty());
231 <            assertEquals(0, q.size());
231 >            mustEqual(0, q.size());
232              assertNull(q.poll());
233          }
234      }
# Line 240 | Line 237 | public class PriorityBlockingQueueTest e
237       * add of comparable succeeds
238       */
239      public void testAdd() {
240 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
240 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
241          for (int i = 0; i < SIZE; ++i) {
242 <            assertEquals(i, q.size());
243 <            assertTrue(q.add(new Integer(i)));
242 >            mustEqual(i, q.size());
243 >            mustAdd(q, i);
244          }
245      }
246  
# Line 251 | Line 248 | public class PriorityBlockingQueueTest e
248       * addAll(this) throws IllegalArgumentException
249       */
250      public void testAddAllSelf() {
251 <        PriorityBlockingQueue q = populatedQueue(SIZE);
251 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
252          try {
253              q.addAll(q);
254              shouldThrow();
# Line 263 | Line 260 | public class PriorityBlockingQueueTest e
260       * possibly adding some elements
261       */
262      public void testAddAll3() {
263 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
264 <        Integer[] ints = new Integer[SIZE];
265 <        for (int i = 0; i < SIZE - 1; ++i)
269 <            ints[i] = new Integer(i);
263 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
264 >        Item[] items = new Item[2];
265 >        items[0] = zero;
266          try {
267 <            q.addAll(Arrays.asList(ints));
267 >            q.addAll(Arrays.asList(items));
268              shouldThrow();
269          } catch (NullPointerException success) {}
270      }
# Line 277 | Line 273 | public class PriorityBlockingQueueTest e
273       * Queue contains all elements of successful addAll
274       */
275      public void testAddAll5() {
276 <        Integer[] empty = new Integer[0];
277 <        Integer[] ints = new Integer[SIZE];
278 <        for (int i = SIZE - 1; i >= 0; --i)
283 <            ints[i] = new Integer(i);
284 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
276 >        Item[] empty = new Item[0];
277 >        Item[] items = defaultItems;
278 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
279          assertFalse(q.addAll(Arrays.asList(empty)));
280 <        assertTrue(q.addAll(Arrays.asList(ints)));
280 >        assertTrue(q.addAll(Arrays.asList(items)));
281          for (int i = 0; i < SIZE; ++i)
282 <            assertEquals(ints[i], q.poll());
282 >            mustEqual(items[i], q.poll());
283      }
284  
285      /**
286       * all elements successfully put are contained
287       */
288      public void testPut() {
289 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
289 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
290          for (int i = 0; i < SIZE; ++i) {
291 <            Integer x = new Integer(i);
291 >            Item x = itemFor(i);
292              q.put(x);
293 <            assertTrue(q.contains(x));
293 >            mustContain(q, x);
294          }
295 <        assertEquals(SIZE, q.size());
295 >        mustEqual(SIZE, q.size());
296      }
297  
298      /**
299       * put doesn't block waiting for take
300       */
301      public void testPutWithTake() throws InterruptedException {
302 <        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
302 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
303          final int size = 4;
304          Thread t = newStartedThread(new CheckedRunnable() {
305              public void realRun() {
306                  for (int i = 0; i < size; i++)
307 <                    q.put(new Integer(0));
307 >                    q.put(zero);
308              }});
309  
310          awaitTermination(t);
311 <        assertEquals(size, q.size());
311 >        mustEqual(size, q.size());
312          q.take();
313      }
314  
# Line 322 | Line 316 | public class PriorityBlockingQueueTest e
316       * Queue is unbounded, so timed offer never times out
317       */
318      public void testTimedOffer() {
319 <        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
319 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
320          Thread t = newStartedThread(new CheckedRunnable() {
321              public void realRun() {
322 <                q.put(new Integer(0));
323 <                q.put(new Integer(0));
324 <                assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
325 <                assertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS));
322 >                q.put(one);
323 >                q.put(two);
324 >                assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
325 >                assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
326              }});
327  
328          awaitTermination(t);
# Line 338 | Line 332 | public class PriorityBlockingQueueTest e
332       * take retrieves elements in priority order
333       */
334      public void testTake() throws InterruptedException {
335 <        PriorityBlockingQueue q = populatedQueue(SIZE);
335 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
336          for (int i = 0; i < SIZE; ++i) {
337 <            assertEquals(i, q.take());
337 >            mustEqual(i, q.take());
338          }
339      }
340  
# Line 348 | Line 342 | public class PriorityBlockingQueueTest e
342       * Take removes existing elements until empty, then blocks interruptibly
343       */
344      public void testBlockingTake() throws InterruptedException {
345 <        final PriorityBlockingQueue q = populatedQueue(SIZE);
345 >        final PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
346          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
347          Thread t = newStartedThread(new CheckedRunnable() {
348              public void realRun() throws InterruptedException {
349 <                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
349 >                for (int i = 0; i < SIZE; i++) mustEqual(i, q.take());
350  
351                  Thread.currentThread().interrupt();
352                  try {
# Line 379 | Line 373 | public class PriorityBlockingQueueTest e
373       * poll succeeds unless empty
374       */
375      public void testPoll() {
376 <        PriorityBlockingQueue q = populatedQueue(SIZE);
376 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
377          for (int i = 0; i < SIZE; ++i) {
378 <            assertEquals(i, q.poll());
378 >            mustEqual(i, q.poll());
379          }
380          assertNull(q.poll());
381      }
# Line 390 | Line 384 | public class PriorityBlockingQueueTest e
384       * timed poll with zero timeout succeeds when non-empty, else times out
385       */
386      public void testTimedPoll0() throws InterruptedException {
387 <        PriorityBlockingQueue q = populatedQueue(SIZE);
387 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
388          for (int i = 0; i < SIZE; ++i) {
389 <            assertEquals(i, q.poll(0, MILLISECONDS));
389 >            mustEqual(i, q.poll(0, MILLISECONDS));
390          }
391          assertNull(q.poll(0, MILLISECONDS));
392      }
# Line 401 | Line 395 | public class PriorityBlockingQueueTest e
395       * timed poll with nonzero timeout succeeds when non-empty, else times out
396       */
397      public void testTimedPoll() throws InterruptedException {
398 <        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
398 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
399          for (int i = 0; i < SIZE; ++i) {
400              long startTime = System.nanoTime();
401 <            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
401 >            mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
402              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
403          }
404          long startTime = System.nanoTime();
# Line 418 | Line 412 | public class PriorityBlockingQueueTest e
412       * returning timeout status
413       */
414      public void testInterruptedTimedPoll() throws InterruptedException {
415 <        final BlockingQueue<Integer> q = populatedQueue(SIZE);
415 >        final BlockingQueue<Item> q = populatedQueue(SIZE);
416          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
417          Thread t = newStartedThread(new CheckedRunnable() {
418              public void realRun() throws InterruptedException {
419                  for (int i = 0; i < SIZE; i++)
420 <                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
420 >                    mustEqual(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
421  
422                  Thread.currentThread().interrupt();
423                  try {
# Line 450 | Line 444 | public class PriorityBlockingQueueTest e
444       * peek returns next element, or null if empty
445       */
446      public void testPeek() {
447 <        PriorityBlockingQueue q = populatedQueue(SIZE);
447 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
448          for (int i = 0; i < SIZE; ++i) {
449 <            assertEquals(i, q.peek());
450 <            assertEquals(i, q.poll());
449 >            mustEqual(i, q.peek());
450 >            mustEqual(i, q.poll());
451              assertTrue(q.peek() == null ||
452                         !q.peek().equals(i));
453          }
# Line 464 | Line 458 | public class PriorityBlockingQueueTest e
458       * element returns next element, or throws NSEE if empty
459       */
460      public void testElement() {
461 <        PriorityBlockingQueue q = populatedQueue(SIZE);
461 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
462          for (int i = 0; i < SIZE; ++i) {
463 <            assertEquals(i, q.element());
464 <            assertEquals(i, q.poll());
463 >            mustEqual(i, q.element());
464 >            mustEqual(i, q.poll());
465          }
466          try {
467              q.element();
# Line 479 | Line 473 | public class PriorityBlockingQueueTest e
473       * remove removes next element, or throws NSEE if empty
474       */
475      public void testRemove() {
476 <        PriorityBlockingQueue q = populatedQueue(SIZE);
476 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
477          for (int i = 0; i < SIZE; ++i) {
478 <            assertEquals(i, q.remove());
478 >            mustEqual(i, q.remove());
479          }
480          try {
481              q.remove();
# Line 493 | Line 487 | public class PriorityBlockingQueueTest e
487       * contains(x) reports true when elements added but not yet removed
488       */
489      public void testContains() {
490 <        PriorityBlockingQueue q = populatedQueue(SIZE);
490 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
491          for (int i = 0; i < SIZE; ++i) {
492 <            assertTrue(q.contains(new Integer(i)));
492 >            mustContain(q, i);
493              q.poll();
494 <            assertFalse(q.contains(new Integer(i)));
494 >            mustNotContain(q, i);
495          }
496      }
497  
# Line 505 | Line 499 | public class PriorityBlockingQueueTest e
499       * clear removes all elements
500       */
501      public void testClear() {
502 <        PriorityBlockingQueue q = populatedQueue(SIZE);
502 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
503          q.clear();
504          assertTrue(q.isEmpty());
505 <        assertEquals(0, q.size());
505 >        mustEqual(0, q.size());
506          q.add(one);
507          assertFalse(q.isEmpty());
508 <        assertTrue(q.contains(one));
508 >        mustContain(q, one);
509          q.clear();
510          assertTrue(q.isEmpty());
511      }
# Line 520 | Line 514 | public class PriorityBlockingQueueTest e
514       * containsAll(c) is true when c contains a subset of elements
515       */
516      public void testContainsAll() {
517 <        PriorityBlockingQueue q = populatedQueue(SIZE);
518 <        PriorityBlockingQueue p = new PriorityBlockingQueue(SIZE);
517 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
518 >        PriorityBlockingQueue<Item> p = new PriorityBlockingQueue<Item>(SIZE);
519          for (int i = 0; i < SIZE; ++i) {
520              assertTrue(q.containsAll(p));
521              assertFalse(p.containsAll(q));
522 <            p.add(new Integer(i));
522 >            mustAdd(p, i);
523          }
524          assertTrue(p.containsAll(q));
525      }
# Line 534 | Line 528 | public class PriorityBlockingQueueTest e
528       * retainAll(c) retains only those elements of c and reports true if changed
529       */
530      public void testRetainAll() {
531 <        PriorityBlockingQueue q = populatedQueue(SIZE);
532 <        PriorityBlockingQueue p = populatedQueue(SIZE);
531 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
532 >        PriorityBlockingQueue<Item> p = populatedQueue(SIZE);
533          for (int i = 0; i < SIZE; ++i) {
534              boolean changed = q.retainAll(p);
535              if (i == 0)
# Line 544 | Line 538 | public class PriorityBlockingQueueTest e
538                  assertTrue(changed);
539  
540              assertTrue(q.containsAll(p));
541 <            assertEquals(SIZE - i, q.size());
541 >            mustEqual(SIZE - i, q.size());
542              p.remove();
543          }
544      }
# Line 554 | Line 548 | public class PriorityBlockingQueueTest e
548       */
549      public void testRemoveAll() {
550          for (int i = 1; i < SIZE; ++i) {
551 <            PriorityBlockingQueue q = populatedQueue(SIZE);
552 <            PriorityBlockingQueue p = populatedQueue(i);
551 >            PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
552 >            PriorityBlockingQueue<Item> p = populatedQueue(i);
553              assertTrue(q.removeAll(p));
554 <            assertEquals(SIZE - i, q.size());
554 >            mustEqual(SIZE - i, q.size());
555              for (int j = 0; j < i; ++j) {
556 <                Integer x = (Integer)(p.remove());
557 <                assertFalse(q.contains(x));
556 >                Item x = p.remove();
557 >                mustNotContain(q, x);
558              }
559          }
560      }
# Line 569 | Line 563 | public class PriorityBlockingQueueTest e
563       * toArray contains all elements
564       */
565      public void testToArray() throws InterruptedException {
566 <        PriorityBlockingQueue q = populatedQueue(SIZE);
566 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
567          Object[] a = q.toArray();
568          assertSame(Object[].class, a.getClass());
569          Arrays.sort(a);
# Line 582 | Line 576 | public class PriorityBlockingQueueTest e
576       * toArray(a) contains all elements
577       */
578      public void testToArray2() throws InterruptedException {
579 <        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
580 <        Integer[] ints = new Integer[SIZE];
581 <        Integer[] array = q.toArray(ints);
582 <        assertSame(ints, array);
583 <        Arrays.sort(ints);
584 <        for (Integer o : ints)
579 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
580 >        Item[] items = new Item[SIZE];
581 >        Item[] array = q.toArray(items);
582 >        assertSame(items, array);
583 >        Arrays.sort(items);
584 >        for (Item o : items)
585              assertSame(o, q.take());
586          assertTrue(q.isEmpty());
587      }
# Line 596 | Line 590 | public class PriorityBlockingQueueTest e
590       * toArray(incompatible array type) throws ArrayStoreException
591       */
592      public void testToArray1_BadArg() {
593 <        PriorityBlockingQueue q = populatedQueue(SIZE);
593 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
594          try {
595              q.toArray(new String[10]);
596              shouldThrow();
# Line 607 | Line 601 | public class PriorityBlockingQueueTest e
601       * iterator iterates through all elements
602       */
603      public void testIterator() {
604 <        PriorityBlockingQueue q = populatedQueue(SIZE);
605 <        Iterator it = q.iterator();
604 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
605 >        Iterator<? extends Item> it = q.iterator();
606          int i;
607          for (i = 0; it.hasNext(); i++)
608 <            assertTrue(q.contains(it.next()));
609 <        assertEquals(i, SIZE);
608 >            mustContain(q, it.next());
609 >        mustEqual(i, SIZE);
610          assertIteratorExhausted(it);
611      }
612  
# Line 620 | Line 614 | public class PriorityBlockingQueueTest e
614       * iterator of empty collection has no elements
615       */
616      public void testEmptyIterator() {
617 <        assertIteratorExhausted(new PriorityBlockingQueue().iterator());
617 >        assertIteratorExhausted(new PriorityBlockingQueue<Item>().iterator());
618      }
619  
620      /**
621       * iterator.remove removes current element
622       */
623      public void testIteratorRemove() {
624 <        final PriorityBlockingQueue q = new PriorityBlockingQueue(3);
625 <        q.add(new Integer(2));
626 <        q.add(new Integer(1));
627 <        q.add(new Integer(3));
624 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(3);
625 >        q.add(two);
626 >        q.add(one);
627 >        q.add(three);
628  
629 <        Iterator it = q.iterator();
629 >        Iterator<? extends Item> it = q.iterator();
630          it.next();
631          it.remove();
632  
633          it = q.iterator();
634 <        assertEquals(it.next(), new Integer(2));
635 <        assertEquals(it.next(), new Integer(3));
634 >        mustEqual(it.next(), two);
635 >        mustEqual(it.next(), three);
636          assertFalse(it.hasNext());
637      }
638  
# Line 646 | Line 640 | public class PriorityBlockingQueueTest e
640       * toString contains toStrings of elements
641       */
642      public void testToString() {
643 <        PriorityBlockingQueue q = populatedQueue(SIZE);
643 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
644          String s = q.toString();
645          for (int i = 0; i < SIZE; ++i) {
646              assertTrue(s.contains(String.valueOf(i)));
# Line 657 | Line 651 | public class PriorityBlockingQueueTest e
651       * timed poll transfers elements across Executor tasks
652       */
653      public void testPollInExecutor() {
654 <        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
654 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
655          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
656          final ExecutorService executor = Executors.newFixedThreadPool(2);
657          try (PoolCleaner cleaner = cleaner(executor)) {
# Line 681 | Line 675 | public class PriorityBlockingQueueTest e
675       * A deserialized/reserialized queue has same elements
676       */
677      public void testSerialization() throws Exception {
678 <        Queue x = populatedQueue(SIZE);
679 <        Queue y = serialClone(x);
678 >        Queue<Item> x = populatedQueue(SIZE);
679 >        Queue<Item> y = serialClone(x);
680  
681          assertNotSame(x, y);
682 <        assertEquals(x.size(), y.size());
682 >        mustEqual(x.size(), y.size());
683          while (!x.isEmpty()) {
684              assertFalse(y.isEmpty());
685 <            assertEquals(x.remove(), y.remove());
685 >            mustEqual(x.remove(), y.remove());
686          }
687          assertTrue(y.isEmpty());
688      }
# Line 697 | Line 691 | public class PriorityBlockingQueueTest e
691       * drainTo(c) empties queue into another collection c
692       */
693      public void testDrainTo() {
694 <        PriorityBlockingQueue q = populatedQueue(SIZE);
695 <        ArrayList l = new ArrayList();
694 >        PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
695 >        ArrayList<Item> l = new ArrayList<Item>();
696          q.drainTo(l);
697 <        assertEquals(0, q.size());
698 <        assertEquals(SIZE, l.size());
697 >        mustEqual(0, q.size());
698 >        mustEqual(SIZE, l.size());
699          for (int i = 0; i < SIZE; ++i)
700 <            assertEquals(l.get(i), new Integer(i));
700 >            mustEqual(l.get(i), i);
701          q.add(zero);
702          q.add(one);
703          assertFalse(q.isEmpty());
704 <        assertTrue(q.contains(zero));
711 <        assertTrue(q.contains(one));
704 >        mustContain(q, one);
705          l.clear();
706          q.drainTo(l);
707 <        assertEquals(0, q.size());
708 <        assertEquals(2, l.size());
707 >        mustEqual(0, q.size());
708 >        mustEqual(2, l.size());
709          for (int i = 0; i < 2; ++i)
710 <            assertEquals(l.get(i), new Integer(i));
710 >            mustEqual(l.get(i), i);
711      }
712  
713      /**
714       * drainTo empties queue
715       */
716      public void testDrainToWithActivePut() throws InterruptedException {
717 <        final PriorityBlockingQueue q = populatedQueue(SIZE);
717 >        final PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
718          Thread t = new Thread(new CheckedRunnable() {
719              public void realRun() {
720 <                q.put(new Integer(SIZE + 1));
720 >                q.put(new Item(SIZE + 1));
721              }});
722  
723          t.start();
724 <        ArrayList l = new ArrayList();
724 >        ArrayList<Item> l = new ArrayList<Item>();
725          q.drainTo(l);
726          assertTrue(l.size() >= SIZE);
727          for (int i = 0; i < SIZE; ++i)
728 <            assertEquals(l.get(i), new Integer(i));
728 >            mustEqual(l.get(i), i);
729          t.join();
730          assertTrue(q.size() + l.size() >= SIZE);
731      }
# Line 741 | Line 734 | public class PriorityBlockingQueueTest e
734       * drainTo(c, n) empties first min(n, size) elements of queue into c
735       */
736      public void testDrainToN() {
737 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
737 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE * 2);
738          for (int i = 0; i < SIZE + 2; ++i) {
739              for (int j = 0; j < SIZE; j++)
740 <                assertTrue(q.offer(new Integer(j)));
741 <            ArrayList l = new ArrayList();
740 >                mustOffer(q, j);
741 >            ArrayList<Item> l = new ArrayList<Item>();
742              q.drainTo(l, i);
743              int k = (i < SIZE) ? i : SIZE;
744 <            assertEquals(k, l.size());
745 <            assertEquals(SIZE - k, q.size());
744 >            mustEqual(k, l.size());
745 >            mustEqual(SIZE - k, q.size());
746              for (int j = 0; j < k; ++j)
747 <                assertEquals(l.get(j), new Integer(j));
747 >                mustEqual(l.get(j), j);
748              do {} while (q.poll() != null);
749          }
750      }

Diff Legend

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