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.20 by jsr166, Sat Nov 21 19:11:53 2009 UTC vs.
Revision 1.72 by jsr166, Sat Mar 25 21:41:10 2017 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9 import junit.framework.*;
10 import java.util.*;
11 import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 < import java.io.*;
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;
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 java.util.concurrent.PriorityBlockingQueue;
23 >
24 > import junit.framework.Test;
25  
26   public class PriorityBlockingQueueTest extends JSR166TestCase {
27 +
28 +    public static class Generic extends BlockingQueueTest {
29 +        protected BlockingQueue emptyCollection() {
30 +            return new PriorityBlockingQueue();
31 +        }
32 +    }
33 +
34 +    public static class InitialCapacity extends BlockingQueueTest {
35 +        protected BlockingQueue emptyCollection() {
36 +            return new PriorityBlockingQueue(SIZE);
37 +        }
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() {
45 <        return new TestSuite(PriorityBlockingQueueTest.class);
45 >        class Implementation implements CollectionImplementation {
46 >            public Class<?> klazz() { return PriorityBlockingQueue.class; }
47 >            public Collection emptyCollection() { return new PriorityBlockingQueue(); }
48 >            public Object makeElement(int i) { return i; }
49 >            public boolean isConcurrent() { return true; }
50 >            public boolean permitsNulls() { return false; }
51 >        }
52 >        return newTestSuite(PriorityBlockingQueueTest.class,
53 >                            new Generic().testSuite(),
54 >                            new InitialCapacity().testSuite(),
55 >                            CollectionTest.testSuite(new Implementation()));
56      }
57  
23    private static final int NOCAP = Integer.MAX_VALUE;
24
58      /** Sample Comparator */
59      static class MyReverseComparator implements Comparator {
60          public int compare(Object x, Object y) {
61 <            int i = ((Integer)x).intValue();
29 <            int j = ((Integer)y).intValue();
30 <            if (i < j) return 1;
31 <            if (i > j) return -1;
32 <            return 0;
61 >            return ((Comparable)y).compareTo(x);
62          }
63      }
64  
65      /**
66 <     * Create a queue of given size containing consecutive
67 <     * Integers 0 ... n.
66 >     * Returns a new queue of given size containing consecutive
67 >     * Integers 0 ... n - 1.
68       */
69 <    private PriorityBlockingQueue populatedQueue(int n) {
70 <        PriorityBlockingQueue q = new PriorityBlockingQueue(n);
69 >    private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
70 >        PriorityBlockingQueue<Integer> q =
71 >            new PriorityBlockingQueue<Integer>(n);
72          assertTrue(q.isEmpty());
73 <        for (int i = n-1; i >= 0; i-=2)
73 >        for (int i = n - 1; i >= 0; i -= 2)
74              assertTrue(q.offer(new Integer(i)));
75 <        for (int i = (n & 1); i < n; i+=2)
75 >        for (int i = (n & 1); i < n; i += 2)
76              assertTrue(q.offer(new Integer(i)));
77          assertFalse(q.isEmpty());
78 <        assertEquals(NOCAP, q.remainingCapacity());
78 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
79          assertEquals(n, q.size());
80 +        assertEquals((Integer) 0, q.peek());
81          return q;
82      }
83  
# Line 54 | Line 85 | public class PriorityBlockingQueueTest e
85       * A new queue has unbounded capacity
86       */
87      public void testConstructor1() {
88 <        assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
88 >        assertEquals(Integer.MAX_VALUE,
89 >                     new PriorityBlockingQueue(SIZE).remainingCapacity());
90      }
91  
92      /**
# Line 62 | Line 94 | public class PriorityBlockingQueueTest e
94       */
95      public void testConstructor2() {
96          try {
97 <            PriorityBlockingQueue q = new PriorityBlockingQueue(0);
97 >            new PriorityBlockingQueue(0);
98              shouldThrow();
99          } catch (IllegalArgumentException success) {}
100      }
# Line 72 | Line 104 | public class PriorityBlockingQueueTest e
104       */
105      public void testConstructor3() {
106          try {
107 <            PriorityBlockingQueue q = new PriorityBlockingQueue(null);
107 >            new PriorityBlockingQueue(null);
108              shouldThrow();
109          } catch (NullPointerException success) {}
110      }
# Line 81 | Line 113 | public class PriorityBlockingQueueTest e
113       * Initializing from Collection of null elements throws NPE
114       */
115      public void testConstructor4() {
116 +        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
117          try {
118 <            Integer[] ints = new Integer[SIZE];
86 <            PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
118 >            new PriorityBlockingQueue(elements);
119              shouldThrow();
120          } catch (NullPointerException success) {}
121      }
# Line 92 | Line 124 | public class PriorityBlockingQueueTest e
124       * Initializing from Collection with some null elements throws NPE
125       */
126      public void testConstructor5() {
127 +        Integer[] ints = new Integer[SIZE];
128 +        for (int i = 0; i < SIZE - 1; ++i)
129 +            ints[i] = i;
130 +        Collection<Integer> elements = Arrays.asList(ints);
131          try {
132 <            Integer[] ints = new Integer[SIZE];
97 <            for (int i = 0; i < SIZE-1; ++i)
98 <                ints[i] = new Integer(i);
99 <            PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
132 >            new PriorityBlockingQueue(elements);
133              shouldThrow();
134          } catch (NullPointerException success) {}
135      }
# Line 107 | Line 140 | public class PriorityBlockingQueueTest e
140      public void testConstructor6() {
141          Integer[] ints = new Integer[SIZE];
142          for (int i = 0; i < SIZE; ++i)
143 <            ints[i] = new Integer(i);
143 >            ints[i] = i;
144          PriorityBlockingQueue q = new PriorityBlockingQueue(Arrays.asList(ints));
145          for (int i = 0; i < SIZE; ++i)
146              assertEquals(ints[i], q.poll());
# Line 124 | Line 157 | public class PriorityBlockingQueueTest e
157          for (int i = 0; i < SIZE; ++i)
158              ints[i] = new Integer(i);
159          q.addAll(Arrays.asList(ints));
160 <        for (int i = SIZE-1; i >= 0; --i)
160 >        for (int i = SIZE - 1; i >= 0; --i)
161              assertEquals(ints[i], q.poll());
162      }
163  
# Line 134 | Line 167 | public class PriorityBlockingQueueTest e
167      public void testEmpty() {
168          PriorityBlockingQueue q = new PriorityBlockingQueue(2);
169          assertTrue(q.isEmpty());
170 <        assertEquals(NOCAP, q.remainingCapacity());
170 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
171          q.add(one);
172          assertFalse(q.isEmpty());
173          q.add(two);
# Line 144 | Line 177 | public class PriorityBlockingQueueTest e
177      }
178  
179      /**
180 <     * remainingCapacity does not change when elements added or removed,
148 <     * but size does
180 >     * remainingCapacity() always returns Integer.MAX_VALUE
181       */
182      public void testRemainingCapacity() {
183 <        PriorityBlockingQueue q = populatedQueue(SIZE);
183 >        BlockingQueue q = populatedQueue(SIZE);
184          for (int i = 0; i < SIZE; ++i) {
185 <            assertEquals(NOCAP, q.remainingCapacity());
186 <            assertEquals(SIZE-i, q.size());
187 <            q.remove();
185 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
186 >            assertEquals(SIZE - i, q.size());
187 >            assertEquals(i, q.remove());
188          }
189          for (int i = 0; i < SIZE; ++i) {
190 <            assertEquals(NOCAP, q.remainingCapacity());
190 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
191              assertEquals(i, q.size());
192 <            q.add(new Integer(i));
192 >            assertTrue(q.add(i));
193          }
194      }
195  
196      /**
165     * offer(null) throws NPE
166     */
167    public void testOfferNull() {
168        try {
169            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
170            q.offer(null);
171            shouldThrow();
172        } catch (NullPointerException success) {}
173    }
174
175    /**
176     * add(null) throws NPE
177     */
178    public void testAddNull() {
179        try {
180            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
181            q.add(null);
182            shouldThrow();
183        } catch (NullPointerException success) {}
184    }
185
186    /**
197       * Offer of comparable element succeeds
198       */
199      public void testOffer() {
# Line 196 | Line 206 | public class PriorityBlockingQueueTest e
206       * Offer of non-Comparable throws CCE
207       */
208      public void testOfferNonComparable() {
209 +        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
210          try {
200            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
201            q.offer(new Object());
202            q.offer(new Object());
211              q.offer(new Object());
212              shouldThrow();
213 <        } catch (ClassCastException success) {}
213 >        } catch (ClassCastException success) {
214 >            assertTrue(q.isEmpty());
215 >            assertEquals(0, q.size());
216 >            assertNull(q.poll());
217 >        }
218      }
219  
220      /**
# Line 217 | Line 229 | public class PriorityBlockingQueueTest e
229      }
230  
231      /**
220     * addAll(null) throws NPE
221     */
222    public void testAddAll1() {
223        try {
224            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
225            q.addAll(null);
226            shouldThrow();
227        } catch (NullPointerException success) {}
228    }
229
230    /**
232       * addAll(this) throws IAE
233       */
234      public void testAddAllSelf() {
235 +        PriorityBlockingQueue q = populatedQueue(SIZE);
236          try {
235            PriorityBlockingQueue q = populatedQueue(SIZE);
237              q.addAll(q);
238              shouldThrow();
239          } catch (IllegalArgumentException success) {}
240      }
241  
242      /**
242     * addAll of a collection with null elements throws NPE
243     */
244    public void testAddAll2() {
245        try {
246            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
247            Integer[] ints = new Integer[SIZE];
248            q.addAll(Arrays.asList(ints));
249            shouldThrow();
250        } catch (NullPointerException success) {}
251    }
252    /**
243       * addAll of a collection with any null elements throws NPE after
244       * possibly adding some elements
245       */
246      public void testAddAll3() {
247 +        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
248 +        Integer[] ints = new Integer[SIZE];
249 +        for (int i = 0; i < SIZE - 1; ++i)
250 +            ints[i] = new Integer(i);
251          try {
258            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
259            Integer[] ints = new Integer[SIZE];
260            for (int i = 0; i < SIZE-1; ++i)
261                ints[i] = new Integer(i);
252              q.addAll(Arrays.asList(ints));
253              shouldThrow();
254          } catch (NullPointerException success) {}
# Line 270 | Line 260 | public class PriorityBlockingQueueTest e
260      public void testAddAll5() {
261          Integer[] empty = new Integer[0];
262          Integer[] ints = new Integer[SIZE];
263 <        for (int i = SIZE-1; i >= 0; --i)
263 >        for (int i = SIZE - 1; i >= 0; --i)
264              ints[i] = new Integer(i);
265          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
266          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 280 | Line 270 | public class PriorityBlockingQueueTest e
270      }
271  
272      /**
283     * put(null) throws NPE
284     */
285     public void testPutNull() {
286        try {
287            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
288            q.put(null);
289            shouldThrow();
290        } catch (NullPointerException success) {}
291     }
292
293    /**
273       * all elements successfully put are contained
274       */
275 <     public void testPut() {
276 <         PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
277 <         for (int i = 0; i < SIZE; ++i) {
278 <             Integer I = new Integer(i);
279 <             q.put(I);
280 <             assertTrue(q.contains(I));
281 <         }
282 <         assertEquals(SIZE, q.size());
275 >    public void testPut() {
276 >        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
277 >        for (int i = 0; i < SIZE; ++i) {
278 >            Integer x = new Integer(i);
279 >            q.put(x);
280 >            assertTrue(q.contains(x));
281 >        }
282 >        assertEquals(SIZE, q.size());
283      }
284  
285      /**
# Line 309 | Line 288 | public class PriorityBlockingQueueTest e
288      public void testPutWithTake() throws InterruptedException {
289          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
290          final int size = 4;
291 <        Thread t = new Thread(new CheckedRunnable() {
291 >        Thread t = newStartedThread(new CheckedRunnable() {
292              public void realRun() {
293                  for (int i = 0; i < size; i++)
294                      q.put(new Integer(0));
295              }});
296  
297 <        t.start();
298 <        Thread.sleep(SHORT_DELAY_MS);
320 <        assertEquals(q.size(), size);
297 >        awaitTermination(t);
298 >        assertEquals(size, q.size());
299          q.take();
322        t.interrupt();
323        t.join();
300      }
301  
302      /**
# Line 328 | Line 304 | public class PriorityBlockingQueueTest e
304       */
305      public void testTimedOffer() throws InterruptedException {
306          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
307 <        Thread t = new Thread(new CheckedRunnable() {
307 >        Thread t = newStartedThread(new CheckedRunnable() {
308              public void realRun() {
309                  q.put(new Integer(0));
310                  q.put(new Integer(0));
311 <                threadAssertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
312 <                threadAssertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS));
311 >                assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
312 >                assertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS));
313              }});
314  
315 <        t.start();
340 <        Thread.sleep(SMALL_DELAY_MS);
341 <        t.interrupt();
342 <        t.join();
315 >        awaitTermination(t);
316      }
317  
318      /**
# Line 348 | Line 321 | public class PriorityBlockingQueueTest e
321      public void testTake() throws InterruptedException {
322          PriorityBlockingQueue q = populatedQueue(SIZE);
323          for (int i = 0; i < SIZE; ++i) {
324 <            assertEquals(i, ((Integer)q.take()).intValue());
324 >            assertEquals(i, q.take());
325          }
326      }
327  
328      /**
356     * take blocks interruptibly when empty
357     */
358    public void testTakeFromEmpty() throws InterruptedException {
359        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
360        Thread t = new Thread(new CheckedInterruptedRunnable() {
361            public void realRun() throws InterruptedException {
362                q.take();
363            }});
364
365        t.start();
366        Thread.sleep(SHORT_DELAY_MS);
367        t.interrupt();
368        t.join();
369    }
370
371    /**
329       * Take removes existing elements until empty, then blocks interruptibly
330       */
331      public void testBlockingTake() throws InterruptedException {
332 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
332 >        final PriorityBlockingQueue q = populatedQueue(SIZE);
333 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
334 >        Thread t = newStartedThread(new CheckedRunnable() {
335              public void realRun() throws InterruptedException {
377                PriorityBlockingQueue q = populatedQueue(SIZE);
336                  for (int i = 0; i < SIZE; ++i) {
337 <                    threadAssertEquals(i, ((Integer)q.take()).intValue());
337 >                    assertEquals(i, q.take());
338                  }
339 <                q.take();
339 >
340 >                Thread.currentThread().interrupt();
341 >                try {
342 >                    q.take();
343 >                    shouldThrow();
344 >                } catch (InterruptedException success) {}
345 >                assertFalse(Thread.interrupted());
346 >
347 >                pleaseInterrupt.countDown();
348 >                try {
349 >                    q.take();
350 >                    shouldThrow();
351 >                } catch (InterruptedException success) {}
352 >                assertFalse(Thread.interrupted());
353              }});
354  
355 <        t.start();
356 <        Thread.sleep(SHORT_DELAY_MS);
355 >        await(pleaseInterrupt);
356 >        assertThreadStaysAlive(t);
357          t.interrupt();
358 <        t.join();
358 >        awaitTermination(t);
359      }
360  
390
361      /**
362       * poll succeeds unless empty
363       */
364      public void testPoll() {
365          PriorityBlockingQueue q = populatedQueue(SIZE);
366          for (int i = 0; i < SIZE; ++i) {
367 <            assertEquals(i, ((Integer)q.poll()).intValue());
367 >            assertEquals(i, q.poll());
368          }
369          assertNull(q.poll());
370      }
371  
372      /**
373 <     * timed pool with zero timeout succeeds when non-empty, else times out
373 >     * timed poll with zero timeout succeeds when non-empty, else times out
374       */
375      public void testTimedPoll0() throws InterruptedException {
376          PriorityBlockingQueue q = populatedQueue(SIZE);
377          for (int i = 0; i < SIZE; ++i) {
378 <            assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
378 >            assertEquals(i, q.poll(0, MILLISECONDS));
379          }
380          assertNull(q.poll(0, MILLISECONDS));
381      }
382  
383      /**
384 <     * timed pool with nonzero timeout succeeds when non-empty, else times out
384 >     * timed poll with nonzero timeout succeeds when non-empty, else times out
385       */
386      public void testTimedPoll() throws InterruptedException {
387 <        PriorityBlockingQueue q = populatedQueue(SIZE);
387 >        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
388          for (int i = 0; i < SIZE; ++i) {
389 <            assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
390 <        }
391 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
389 >            long startTime = System.nanoTime();
390 >            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
391 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
392 >        }
393 >        long startTime = System.nanoTime();
394 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
395 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
396 >        checkEmpty(q);
397      }
398  
399      /**
# Line 426 | Line 401 | public class PriorityBlockingQueueTest e
401       * returning timeout status
402       */
403      public void testInterruptedTimedPoll() throws InterruptedException {
404 <        Thread t = new Thread(new CheckedRunnable() {
404 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
405 >        final CountDownLatch aboutToWait = new CountDownLatch(1);
406 >        Thread t = newStartedThread(new CheckedRunnable() {
407              public void realRun() throws InterruptedException {
408 <                PriorityBlockingQueue q = populatedQueue(SIZE);
408 >                long startTime = System.nanoTime();
409                  for (int i = 0; i < SIZE; ++i) {
410 <                    assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
410 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
411                  }
412 <                try {
436 <                    q.poll(SMALL_DELAY_MS, MILLISECONDS);
437 <                    shouldThrow();
438 <                } catch (InterruptedException success) {}
439 <            }});
440 <
441 <        t.start();
442 <        Thread.sleep(SHORT_DELAY_MS);
443 <        t.interrupt();
444 <        t.join();
445 <    }
446 <
447 <    /**
448 <     *  timed poll before a delayed offer fails; after offer succeeds;
449 <     *  on interruption throws
450 <     */
451 <    public void testTimedPollWithOffer() throws InterruptedException {
452 <        final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
453 <        Thread t = new Thread(new CheckedRunnable() {
454 <            public void realRun() throws InterruptedException {
455 <                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
456 <                assertEquals(0, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
412 >                aboutToWait.countDown();
413                  try {
414                      q.poll(LONG_DELAY_MS, MILLISECONDS);
415 <                    threadShouldThrow();
416 <                } catch (InterruptedException success) {}
415 >                    shouldThrow();
416 >                } catch (InterruptedException success) {
417 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
418 >                }
419              }});
420  
421 <        t.start();
422 <        Thread.sleep(SMALL_DELAY_MS);
465 <        assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
421 >        await(aboutToWait);
422 >        waitForThreadToEnterWaitState(t);
423          t.interrupt();
424 <        t.join();
424 >        awaitTermination(t);
425      }
426  
470
427      /**
428       * peek returns next element, or null if empty
429       */
430      public void testPeek() {
431          PriorityBlockingQueue q = populatedQueue(SIZE);
432          for (int i = 0; i < SIZE; ++i) {
433 <            assertEquals(i, ((Integer)q.peek()).intValue());
434 <            q.poll();
433 >            assertEquals(i, q.peek());
434 >            assertEquals(i, q.poll());
435              assertTrue(q.peek() == null ||
436 <                       i != ((Integer)q.peek()).intValue());
436 >                       !q.peek().equals(i));
437          }
438          assertNull(q.peek());
439      }
# Line 488 | Line 444 | public class PriorityBlockingQueueTest e
444      public void testElement() {
445          PriorityBlockingQueue q = populatedQueue(SIZE);
446          for (int i = 0; i < SIZE; ++i) {
447 <            assertEquals(i, ((Integer)q.element()).intValue());
448 <            q.poll();
447 >            assertEquals(i, q.element());
448 >            assertEquals(i, q.poll());
449          }
450          try {
451              q.element();
# Line 503 | Line 459 | public class PriorityBlockingQueueTest e
459      public void testRemove() {
460          PriorityBlockingQueue q = populatedQueue(SIZE);
461          for (int i = 0; i < SIZE; ++i) {
462 <            assertEquals(i, ((Integer)q.remove()).intValue());
462 >            assertEquals(i, q.remove());
463          }
464          try {
465              q.remove();
# Line 512 | Line 468 | public class PriorityBlockingQueueTest e
468      }
469  
470      /**
515     * remove(x) removes x and returns true if present
516     */
517    public void testRemoveElement() {
518        PriorityBlockingQueue q = populatedQueue(SIZE);
519        for (int i = 1; i < SIZE; i+=2) {
520            assertTrue(q.remove(new Integer(i)));
521        }
522        for (int i = 0; i < SIZE; i+=2) {
523            assertTrue(q.remove(new Integer(i)));
524            assertFalse(q.remove(new Integer(i+1)));
525        }
526        assertTrue(q.isEmpty());
527    }
528
529    /**
471       * contains(x) reports true when elements added but not yet removed
472       */
473      public void testContains() {
# Line 581 | Line 522 | public class PriorityBlockingQueueTest e
522                  assertTrue(changed);
523  
524              assertTrue(q.containsAll(p));
525 <            assertEquals(SIZE-i, q.size());
525 >            assertEquals(SIZE - i, q.size());
526              p.remove();
527          }
528      }
# Line 594 | Line 535 | public class PriorityBlockingQueueTest e
535              PriorityBlockingQueue q = populatedQueue(SIZE);
536              PriorityBlockingQueue p = populatedQueue(i);
537              assertTrue(q.removeAll(p));
538 <            assertEquals(SIZE-i, q.size());
538 >            assertEquals(SIZE - i, q.size());
539              for (int j = 0; j < i; ++j) {
540 <                Integer I = (Integer)(p.remove());
541 <                assertFalse(q.contains(I));
540 >                Integer x = (Integer)(p.remove());
541 >                assertFalse(q.contains(x));
542              }
543          }
544      }
545  
546      /**
547 <     *  toArray contains all elements
547 >     * toArray contains all elements
548       */
549      public void testToArray() throws InterruptedException {
550          PriorityBlockingQueue q = populatedQueue(SIZE);
551          Object[] o = q.toArray();
552          Arrays.sort(o);
553          for (int i = 0; i < o.length; i++)
554 <            assertEquals(o[i], q.take());
554 >            assertSame(o[i], q.take());
555      }
556  
557      /**
558       * toArray(a) contains all elements
559       */
560      public void testToArray2() throws InterruptedException {
561 <        PriorityBlockingQueue q = populatedQueue(SIZE);
561 >        PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
562          Integer[] ints = new Integer[SIZE];
563 <        ints = (Integer[])q.toArray(ints);
563 >        Integer[] array = q.toArray(ints);
564 >        assertSame(ints, array);
565          Arrays.sort(ints);
566          for (int i = 0; i < ints.length; i++)
567 <            assertEquals(ints[i], q.take());
626 <    }
627 <
628 <    /**
629 <     * toArray(null) throws NPE
630 <     */
631 <    public void testToArray_BadArg() {
632 <        try {
633 <            PriorityBlockingQueue q = populatedQueue(SIZE);
634 <            Object o[] = q.toArray(null);
635 <            shouldThrow();
636 <        } catch (NullPointerException success) {}
567 >            assertSame(ints[i], q.take());
568      }
569  
570      /**
571 <     * toArray with incompatible array type throws CCE
571 >     * toArray(incompatible array type) throws ArrayStoreException
572       */
573      public void testToArray1_BadArg() {
574 +        PriorityBlockingQueue q = populatedQueue(SIZE);
575          try {
576 <            PriorityBlockingQueue q = populatedQueue(SIZE);
645 <            Object o[] = q.toArray(new String[10] );
576 >            q.toArray(new String[10]);
577              shouldThrow();
578          } catch (ArrayStoreException success) {}
579      }
# Line 652 | Line 583 | public class PriorityBlockingQueueTest e
583       */
584      public void testIterator() {
585          PriorityBlockingQueue q = populatedQueue(SIZE);
655        int i = 0;
586          Iterator it = q.iterator();
587 <        while (it.hasNext()) {
587 >        int i;
588 >        for (i = 0; it.hasNext(); i++)
589              assertTrue(q.contains(it.next()));
659            ++i;
660        }
590          assertEquals(i, SIZE);
591 +        assertIteratorExhausted(it);
592 +    }
593 +
594 +    /**
595 +     * iterator of empty collection has no elements
596 +     */
597 +    public void testEmptyIterator() {
598 +        assertIteratorExhausted(new PriorityBlockingQueue().iterator());
599      }
600  
601      /**
602       * iterator.remove removes current element
603       */
604 <    public void testIteratorRemove () {
604 >    public void testIteratorRemove() {
605          final PriorityBlockingQueue q = new PriorityBlockingQueue(3);
606          q.add(new Integer(2));
607          q.add(new Integer(1));
# Line 680 | Line 617 | public class PriorityBlockingQueueTest e
617          assertFalse(it.hasNext());
618      }
619  
683
620      /**
621       * toString contains toStrings of elements
622       */
# Line 688 | Line 624 | public class PriorityBlockingQueueTest e
624          PriorityBlockingQueue q = populatedQueue(SIZE);
625          String s = q.toString();
626          for (int i = 0; i < SIZE; ++i) {
627 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
627 >            assertTrue(s.contains(String.valueOf(i)));
628          }
629      }
630  
631      /**
632 <     * offer transfers elements across Executor tasks
632 >     * timed poll transfers elements across Executor tasks
633       */
634      public void testPollInExecutor() {
635          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
636 <        ExecutorService executor = Executors.newFixedThreadPool(2);
637 <        executor.execute(new CheckedRunnable() {
638 <            public void realRun() throws InterruptedException {
639 <                threadAssertNull(q.poll());
640 <                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
641 <                threadAssertTrue(q.isEmpty());
642 <            }});
643 <
644 <        executor.execute(new CheckedRunnable() {
645 <            public void realRun() throws InterruptedException {
646 <                Thread.sleep(SMALL_DELAY_MS);
647 <                q.put(new Integer(1));
648 <            }});
649 <
650 <        joinPool(executor);
636 >        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
637 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
638 >        try (PoolCleaner cleaner = cleaner(executor)) {
639 >            executor.execute(new CheckedRunnable() {
640 >                public void realRun() throws InterruptedException {
641 >                    assertNull(q.poll());
642 >                    threadsStarted.await();
643 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
644 >                    checkEmpty(q);
645 >                }});
646 >
647 >            executor.execute(new CheckedRunnable() {
648 >                public void realRun() throws InterruptedException {
649 >                    threadsStarted.await();
650 >                    q.put(one);
651 >                }});
652 >        }
653      }
654  
655      /**
656       * A deserialized serialized queue has same elements
657       */
658      public void testSerialization() throws Exception {
659 <        PriorityBlockingQueue q = populatedQueue(SIZE);
660 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
723 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
724 <        out.writeObject(q);
725 <        out.close();
726 <
727 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
728 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
729 <        PriorityBlockingQueue r = (PriorityBlockingQueue)in.readObject();
730 <        assertEquals(q.size(), r.size());
731 <        while (!q.isEmpty())
732 <            assertEquals(q.remove(), r.remove());
733 <    }
734 <
735 <    /**
736 <     * drainTo(null) throws NPE
737 <     */
738 <    public void testDrainToNull() {
739 <        PriorityBlockingQueue q = populatedQueue(SIZE);
740 <        try {
741 <            q.drainTo(null);
742 <            shouldThrow();
743 <        } catch (NullPointerException success) {}
744 <    }
659 >        Queue x = populatedQueue(SIZE);
660 >        Queue y = serialClone(x);
661  
662 <    /**
663 <     * drainTo(this) throws IAE
664 <     */
665 <    public void testDrainToSelf() {
666 <        PriorityBlockingQueue q = populatedQueue(SIZE);
667 <        try {
668 <            q.drainTo(q);
753 <            shouldThrow();
754 <        } catch (IllegalArgumentException success) {}
662 >        assertNotSame(x, y);
663 >        assertEquals(x.size(), y.size());
664 >        while (!x.isEmpty()) {
665 >            assertFalse(y.isEmpty());
666 >            assertEquals(x.remove(), y.remove());
667 >        }
668 >        assertTrue(y.isEmpty());
669      }
670  
671      /**
# Line 761 | Line 675 | public class PriorityBlockingQueueTest e
675          PriorityBlockingQueue q = populatedQueue(SIZE);
676          ArrayList l = new ArrayList();
677          q.drainTo(l);
678 <        assertEquals(q.size(), 0);
679 <        assertEquals(l.size(), SIZE);
678 >        assertEquals(0, q.size());
679 >        assertEquals(SIZE, l.size());
680          for (int i = 0; i < SIZE; ++i)
681              assertEquals(l.get(i), new Integer(i));
682          q.add(zero);
# Line 772 | Line 686 | public class PriorityBlockingQueueTest e
686          assertTrue(q.contains(one));
687          l.clear();
688          q.drainTo(l);
689 <        assertEquals(q.size(), 0);
690 <        assertEquals(l.size(), 2);
689 >        assertEquals(0, q.size());
690 >        assertEquals(2, l.size());
691          for (int i = 0; i < 2; ++i)
692              assertEquals(l.get(i), new Integer(i));
693      }
# Line 785 | Line 699 | public class PriorityBlockingQueueTest e
699          final PriorityBlockingQueue q = populatedQueue(SIZE);
700          Thread t = new Thread(new CheckedRunnable() {
701              public void realRun() {
702 <                q.put(new Integer(SIZE+1));
702 >                q.put(new Integer(SIZE + 1));
703              }});
704  
705          t.start();
# Line 799 | Line 713 | public class PriorityBlockingQueueTest e
713      }
714  
715      /**
716 <     * drainTo(null, n) throws NPE
803 <     */
804 <    public void testDrainToNullN() {
805 <        PriorityBlockingQueue q = populatedQueue(SIZE);
806 <        try {
807 <            q.drainTo(null, 0);
808 <            shouldThrow();
809 <        } catch (NullPointerException success) {}
810 <    }
811 <
812 <    /**
813 <     * drainTo(this, n) throws IAE
814 <     */
815 <    public void testDrainToSelfN() {
816 <        PriorityBlockingQueue q = populatedQueue(SIZE);
817 <        try {
818 <            q.drainTo(q, 0);
819 <            shouldThrow();
820 <        } catch (IllegalArgumentException success) {}
821 <    }
822 <
823 <    /**
824 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
716 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
717       */
718      public void testDrainToN() {
719 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
719 >        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
720          for (int i = 0; i < SIZE + 2; ++i) {
721              for (int j = 0; j < SIZE; j++)
722                  assertTrue(q.offer(new Integer(j)));
723              ArrayList l = new ArrayList();
724              q.drainTo(l, i);
725 <            int k = (i < SIZE)? i : SIZE;
726 <            assertEquals(l.size(), k);
727 <            assertEquals(q.size(), SIZE-k);
725 >            int k = (i < SIZE) ? i : SIZE;
726 >            assertEquals(k, l.size());
727 >            assertEquals(SIZE - k, q.size());
728              for (int j = 0; j < k; ++j)
729                  assertEquals(l.get(j), new Integer(j));
730 <            while (q.poll() != null) ;
730 >            do {} while (q.poll() != null);
731 >        }
732 >    }
733 >
734 >    /**
735 >     * remove(null), contains(null) always return false
736 >     */
737 >    public void testNeverContainsNull() {
738 >        Collection<?>[] qs = {
739 >            new PriorityBlockingQueue<Object>(),
740 >            populatedQueue(2),
741 >        };
742 >
743 >        for (Collection<?> q : qs) {
744 >            assertFalse(q.contains(null));
745 >            assertFalse(q.remove(null));
746          }
747      }
748  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines