[cvs] / jsr166 / src / test / tck / ArrayBlockingQueueTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/ArrayBlockingQueueTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.6, Sun Oct 5 23:00:39 2003 UTC revision 1.73, Mon Oct 17 01:52:04 2016 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/publicdomain/zero/1.0/
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   */   * Pat Fisher, Mike Judd.
7     */
8    
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.Iterator;
15    import java.util.NoSuchElementException;
16    import java.util.Queue;
17    import java.util.concurrent.ArrayBlockingQueue;
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    
23  import junit.framework.*;  import junit.framework.Test;
 import java.util.*;  
 import java.util.concurrent.*;  
 import java.io.*;  
24    
25  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
26    
27        public static class Fair extends BlockingQueueTest {
28            protected BlockingQueue emptyCollection() {
29                return new ArrayBlockingQueue(SIZE, true);
30            }
31        }
32    
33        public static class NonFair extends BlockingQueueTest {
34            protected BlockingQueue emptyCollection() {
35                return new ArrayBlockingQueue(SIZE, false);
36            }
37        }
38    
39      public static void main(String[] args) {      public static void main(String[] args) {
40          junit.textui.TestRunner.run (suite());          main(suite(), args);
41      }      }
42    
43      public static Test suite() {      public static Test suite() {
44          return new TestSuite(ArrayBlockingQueueTest.class);          class Implementation implements CollectionImplementation {
45                public Class<?> klazz() { return ArrayBlockingQueue.class; }
46                public Collection emptyCollection() { return new ArrayBlockingQueue(SIZE, false); }
47                public Object makeElement(int i) { return i; }
48                public boolean isConcurrent() { return true; }
49                public boolean permitsNulls() { return false; }
50            }
51            return newTestSuite(ArrayBlockingQueueTest.class,
52                                new Fair().testSuite(),
53                                new NonFair().testSuite(),
54                                CollectionTest.testSuite(new Implementation()));
55      }      }
56    
57      /**      /**
58       * Create a queue of given size containing consecutive       * Returns a new queue of given size containing consecutive
59       * Integers 0 ... n.       * Integers 0 ... n - 1.
60       */       */
61      private ArrayBlockingQueue populatedQueue(int n) {      private ArrayBlockingQueue<Integer> populatedQueue(int n) {
62          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
63          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
64          for(int i = 0; i < n; i++)          for(int i = 0; i < n; i++)
65              assertTrue(q.offer(new Integer(i)));              assertTrue(q.offer(new Integer(i)));
66          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
67          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
68          assertEquals(n, q.size());          assertEquals(n, q.size());
69            assertEquals((Integer) 0, q.peek());
70          return q;          return q;
71      }      }
72    
# Line 46  Line 82 
82       */       */
83      public void testConstructor2() {      public void testConstructor2() {
84          try {          try {
85              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              new ArrayBlockingQueue(0);
86              shouldThrow();              shouldThrow();
87          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
88      }      }
89    
90      /**      /**
# Line 57  Line 92 
92       */       */
93      public void testConstructor3() {      public void testConstructor3() {
94          try {          try {
95              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              new ArrayBlockingQueue(1, true, null);
96              shouldThrow();              shouldThrow();
97          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
98      }      }
99    
100      /**      /**
101       * Initializing from Collection of null elements throws NPE       * Initializing from Collection of null elements throws NPE
102       */       */
103      public void testConstructor4() {      public void testConstructor4() {
104            Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
105          try {          try {
106              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE, false, elements);
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));  
107              shouldThrow();              shouldThrow();
108          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
109      }      }
110    
111      /**      /**
112       * Initializing from Collection with some null elements throws NPE       * Initializing from Collection with some null elements throws NPE
113       */       */
114      public void testConstructor5() {      public void testConstructor5() {
         try {  
115              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
116              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
117                  ints[i] = new Integer(i);              ints[i] = i;
118              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
119            try {
120                new ArrayBlockingQueue(SIZE, false, elements);
121              shouldThrow();              shouldThrow();
122          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
123      }      }
124    
125      /**      /**
126       * Initializing from too large collection throws IAE       * Initializing from too large collection throws IAE
127       */       */
128      public void testConstructor6() {      public void testConstructor6() {
         try {  
129              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
130              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
131                  ints[i] = new Integer(i);              ints[i] = i;
132              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
133            try {
134                new ArrayBlockingQueue(SIZE - 1, false, elements);
135              shouldThrow();              shouldThrow();
136          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
137      }      }
138    
139      /**      /**
140       * Queue contains all elements of collection used to initialize       * Queue contains all elements of collection used to initialize
141       */       */
142      public void testConstructor7() {      public void testConstructor7() {
         try {  
143              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
144              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
145                  ints[i] = new Integer(i);              ints[i] = i;
146              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
147            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
148              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
149                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
150          }          }
         finally {}  
     }  
151    
152      /**      /**
153       * Queue transitions from empty to full when elements added       * Queue transitions from empty to full when elements added
# Line 137  Line 168 
168       * remainingCapacity decreases on add, increases on remove       * remainingCapacity decreases on add, increases on remove
169       */       */
170      public void testRemainingCapacity() {      public void testRemainingCapacity() {
171          ArrayBlockingQueue q = populatedQueue(SIZE);          BlockingQueue q = populatedQueue(SIZE);
172          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
173              assertEquals(i, q.remainingCapacity());              assertEquals(i, q.remainingCapacity());
174              assertEquals(SIZE-i, q.size());              assertEquals(SIZE, q.size() + q.remainingCapacity());
175              q.remove();              assertEquals(i, q.remove());
176          }          }
177          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
178              assertEquals(SIZE-i, q.remainingCapacity());              assertEquals(SIZE-i, q.remainingCapacity());
179              assertEquals(i, q.size());              assertEquals(SIZE, q.size() + q.remainingCapacity());
180              q.add(new Integer(i));              assertTrue(q.add(i));
181          }          }
182      }      }
183    
184      /**      /**
      *  offer(null) throws NPE  
      */  
     public void testOfferNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.offer(null);  
             shouldThrow();  
         } catch (NullPointerException success) { }  
     }  
   
     /**  
      *  add(null) throws NPE  
      */  
     public void testAddNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.add(null);  
             shouldThrow();  
         } catch (NullPointerException success) { }  
     }  
   
     /**  
185       * Offer succeeds if not full; fails if full       * Offer succeeds if not full; fails if full
186       */       */
187      public void testOffer() {      public void testOffer() {
# Line 185  Line 194 
194       * add succeeds if not full; throws ISE if full       * add succeeds if not full; throws ISE if full
195       */       */
196      public void testAdd() {      public void testAdd() {
         try {  
197              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
198              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
199                  assertTrue(q.add(new Integer(i)));                  assertTrue(q.add(new Integer(i)));
200              }              }
201              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
             q.add(new Integer(SIZE));  
         } catch (IllegalStateException success){  
         }  
     }  
   
     /**  
      *  addAll(null) throws NPE  
      */  
     public void testAddAll1() {  
202          try {          try {
203              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              q.add(new Integer(SIZE));
             q.addAll(null);  
204              shouldThrow();              shouldThrow();
205          }          } catch (IllegalStateException success) {}
         catch (NullPointerException success) {}  
206      }      }
207    
208      /**      /**
209       * addAll(this) throws IAE       * addAll(this) throws IAE
210       */       */
211      public void testAddAllSelf() {      public void testAddAllSelf() {
         try {  
212              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
213            try {
214              q.addAll(q);              q.addAll(q);
215              shouldThrow();              shouldThrow();
216          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
217      }      }
218    
   
     /**  
      *  addAll of a collection with null elements throws NPE  
      */  
     public void testAddAll2() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
             Integer[] ints = new Integer[SIZE];  
             q.addAll(Arrays.asList(ints));  
             shouldThrow();  
         }  
         catch (NullPointerException success) {}  
     }  
219      /**      /**
220       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
221       * possibly adding some elements       * possibly adding some elements
222       */       */
223      public void testAddAll3() {      public void testAddAll3() {
         try {  
224              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
225              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
226              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
227                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
228            try {
229              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
230              shouldThrow();              shouldThrow();
231            } catch (NullPointerException success) {}
232          }          }
233          catch (NullPointerException success) {}  
     }  
234      /**      /**
235       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
236       */       */
237      public void testAddAll4() {      public void testAddAll4() {
         try {  
238              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
239              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
240              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
241                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
242            try {
243              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
244              shouldThrow();              shouldThrow();
245            } catch (IllegalStateException success) {}
246          }          }
247          catch (IllegalStateException success) {}  
     }  
248      /**      /**
249       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
250       */       */
251      public void testAddAll5() {      public void testAddAll5() {
         try {  
252              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
253              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
254              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 277  Line 259 
259              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
260                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
261          }          }
         finally {}  
     }  
   
     /**  
      *  put(null) throws NPE  
      */  
      public void testPutNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
             q.put(null);  
             shouldThrow();  
         }  
         catch (NullPointerException success){  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
      }  
262    
263      /**      /**
264       * all elements successfully put are contained       * all elements successfully put are contained
265       */       */
266       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
267               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
268               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
269                   Integer I = new Integer(i);              Integer x = new Integer(i);
270                   q.put(I);              q.put(x);
271                   assertTrue(q.contains(I));              assertTrue(q.contains(x));
272               }               }
273               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
274           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
275    
276      /**      /**
277       * put blocks interruptibly if full       * put blocks interruptibly if full
278       */       */
279      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
280          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
281                  public void run() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
282                      int added = 0;          Thread t = newStartedThread(new CheckedRunnable() {
283                public void realRun() throws InterruptedException {
284                    for (int i = 0; i < SIZE; ++i)
285                        q.put(i);
286                    assertEquals(SIZE, q.size());
287                    assertEquals(0, q.remainingCapacity());
288    
289                    Thread.currentThread().interrupt();
290                      try {                      try {
291                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                      q.put(99);
292                          for (int i = 0; i < SIZE; ++i) {                      shouldThrow();
293                              q.put(new Integer(i));                  } catch (InterruptedException success) {}
294                              ++added;                  assertFalse(Thread.interrupted());
295                          }  
296                          q.put(new Integer(SIZE));                  pleaseInterrupt.countDown();
                         threadShouldThrow();  
                     } catch (InterruptedException ie){  
                         threadAssertEquals(added, SIZE);  
                     }  
                 }});  
297          try {          try {
298              t.start();                      q.put(99);
299             Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
300                    } catch (InterruptedException success) {}
301                    assertFalse(Thread.interrupted());
302                }});
303    
304            await(pleaseInterrupt);
305            assertThreadStaysAlive(t);
306             t.interrupt();             t.interrupt();
307             t.join();          awaitTermination(t);
308          }          assertEquals(SIZE, q.size());
309          catch (InterruptedException ie) {          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
310      }      }
311    
312      /**      /**
313       * put blocks waiting for take when full       * put blocks interruptibly waiting for take when full
314       */       */
315      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
316          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
317          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
318                  public void run() {          final CountDownLatch pleaseTake = new CountDownLatch(1);
319                      int added = 0;          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
320                      try {          Thread t = newStartedThread(new CheckedRunnable() {
321                          q.put(new Object());              public void realRun() throws InterruptedException {
322                          ++added;                  for (int i = 0; i < capacity; i++)
323                          q.put(new Object());                      q.put(i);
324                          ++added;                  pleaseTake.countDown();
325                          q.put(new Object());                  q.put(86);
326                          ++added;  
327                          q.put(new Object());                  pleaseInterrupt.countDown();
                         ++added;  
                         threadShouldThrow();  
                     } catch (InterruptedException e){  
                         threadAssertTrue(added >= 2);  
                     }  
                 }  
             });  
328          try {          try {
329              t.start();                      q.put(99);
330              Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
331              q.take();                  } catch (InterruptedException success) {}
332                    assertFalse(Thread.interrupted());
333                }});
334    
335            await(pleaseTake);
336            assertEquals(0, q.remainingCapacity());
337            assertEquals(0, q.take());
338    
339            await(pleaseInterrupt);
340            assertThreadStaysAlive(t);
341              t.interrupt();              t.interrupt();
342              t.join();          awaitTermination(t);
343          } catch (Exception e){          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
344      }      }
345    
346      /**      /**
347       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
348       */       */
349      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
350          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
351          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
352                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
353                      try {              public void realRun() throws InterruptedException {
354                          q.put(new Object());                          q.put(new Object());
355                          q.put(new Object());                          q.put(new Object());
356                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  long startTime = System.nanoTime();
357                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
358                          threadShouldThrow();                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
359                    pleaseInterrupt.countDown();
360                    try {
361                        q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
362                        shouldThrow();
363                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
364                  }              }});
             });  
365    
366          try {          await(pleaseInterrupt);
367              t.start();          assertThreadStaysAlive(t);
             Thread.sleep(SHORT_DELAY_MS);  
368              t.interrupt();              t.interrupt();
369              t.join();          awaitTermination(t);
         } catch (Exception e){  
             unexpectedException();  
         }  
370      }      }
371    
372      /**      /**
373       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
374       */       */
375      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
376              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
377              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
378                  assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
379          }          }
380      }      }
381    
382      /**      /**
383       * take blocks interruptibly when empty       * Take removes existing elements until empty, then blocks interruptibly
384       */       */
385      public void testTakeFromEmpty() {      public void testBlockingTake() throws InterruptedException {
386          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = populatedQueue(SIZE);
387          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
388                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
389                public void realRun() throws InterruptedException {
390                    for (int i = 0; i < SIZE; ++i) {
391                        assertEquals(i, q.take());
392                    }
393    
394                    Thread.currentThread().interrupt();
395                      try {                      try {
396                          q.take();                          q.take();
397                          threadShouldThrow();                      shouldThrow();
398                      } catch (InterruptedException success){ }                      } catch (InterruptedException success){ }
399                  }                  assertFalse(Thread.interrupted());
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         } catch (Exception e){  
             unexpectedException();  
         }  
     }  
400    
401      /**                  pleaseInterrupt.countDown();
      * Take removes existing elements until empty, then blocks interruptibly  
      */  
     public void testBlockingTake() {  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
402                      try {                      try {
                         ArrayBlockingQueue q = populatedQueue(SIZE);  
                         for (int i = 0; i < SIZE; ++i) {  
                             threadAssertEquals(i, ((Integer)q.take()).intValue());  
                         }  
403                          q.take();                          q.take();
404                          threadShouldThrow();                      shouldThrow();
405                      } catch (InterruptedException success){                  } catch (InterruptedException success) {}
406                      }                  assertFalse(Thread.interrupted());
407                  }});                  }});
408          try {  
409              t.start();          await(pleaseInterrupt);
410              Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
411              t.interrupt();              t.interrupt();
412              t.join();          awaitTermination(t);
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
413      }      }
414    
   
415      /**      /**
416       * poll succeeds unless empty       * poll succeeds unless empty
417       */       */
418      public void testPoll() {      public void testPoll() {
419          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
420          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
421              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
422          }          }
423          assertNull(q.poll());          assertNull(q.poll());
424      }      }
425    
426      /**      /**
427       * timed pool with zero timeout succeeds when non-empty, else times out       * timed poll with zero timeout succeeds when non-empty, else times out
428       */       */
429      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
430              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
431              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
432                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());              assertEquals(i, q.poll(0, MILLISECONDS));
             }  
             assertNull(q.poll(0, TimeUnit.MILLISECONDS));  
         } catch (InterruptedException e){  
             unexpectedException();  
433          }          }
434            assertNull(q.poll(0, MILLISECONDS));
435            checkEmpty(q);
436      }      }
437    
438      /**      /**
439       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed poll with nonzero timeout succeeds when non-empty, else times out
440       */       */
441      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
442              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
443              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
444                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());              long startTime = System.nanoTime();
445              }              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
446              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
         } catch (InterruptedException e){  
             unexpectedException();  
447          }          }
448            long startTime = System.nanoTime();
449            assertNull(q.poll(timeoutMillis(), MILLISECONDS));
450            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
451            checkEmpty(q);
452      }      }
453    
454      /**      /**
455       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
456       * returning timeout status       * returning timeout status
457       */       */
458      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
459          Thread t = new Thread(new Runnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
460                  public void run() {          final CountDownLatch aboutToWait = new CountDownLatch(1);
461                      try {          Thread t = newStartedThread(new CheckedRunnable() {
462                          ArrayBlockingQueue q = populatedQueue(SIZE);              public void realRun() throws InterruptedException {
463                    long startTime = System.nanoTime();
464                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
465                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
466                          }                          }
467                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                  aboutToWait.countDown();
468                    try {
469                        q.poll(LONG_DELAY_MS, MILLISECONDS);
470                        shouldThrow();
471                      } catch (InterruptedException success){                      } catch (InterruptedException success){
472                        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
473                      }                      }
474                  }});                  }});
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
475    
476      /**          await(aboutToWait);
477       *  timed poll before a delayed offer fails; after offer succeeds;          waitForThreadToEnterWaitState(t);
      *  on interruption throws  
      */  
     public void testTimedPollWithOffer() {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);  
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);  
                         threadShouldThrow();  
                     } catch (InterruptedException success) { }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SMALL_DELAY_MS);  
             assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
478              t.interrupt();              t.interrupt();
479              t.join();          awaitTermination(t);
480          } catch (Exception e){          checkEmpty(q);
             unexpectedException();  
         }  
481      }      }
482    
   
483      /**      /**
484       * peek returns next element, or null if empty       * peek returns next element, or null if empty
485       */       */
486      public void testPeek() {      public void testPeek() {
487          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
488          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
489              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
490              q.poll();              assertEquals(i, q.poll());
491              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
492                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
493          }          }
494          assertNull(q.peek());          assertNull(q.peek());
495      }      }
# Line 586  Line 500 
500      public void testElement() {      public void testElement() {
501          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
502          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
503              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
504              q.poll();              assertEquals(i, q.poll());
505          }          }
506          try {          try {
507              q.element();              q.element();
508              shouldThrow();              shouldThrow();
509          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
510      }      }
511    
512      /**      /**
# Line 602  Line 515 
515      public void testRemove() {      public void testRemove() {
516          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
517          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
518              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
519          }          }
520          try {          try {
521              q.remove();              q.remove();
522              shouldThrow();              shouldThrow();
523          } catch (NoSuchElementException success){          } catch (NoSuchElementException success) {}
         }  
     }  
   
     /**  
      * remove(x) removes x and returns true if present  
      */  
     public void testRemoveElement() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         for (int i = 1; i < SIZE; i+=2) {  
             assertTrue(q.remove(new Integer(i)));  
         }  
         for (int i = 0; i < SIZE; i+=2) {  
             assertTrue(q.remove(new Integer(i)));  
             assertFalse(q.remove(new Integer(i+1)));  
         }  
         assertTrue(q.isEmpty());  
524      }      }
525    
526      /**      /**
# Line 633  Line 530 
530          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
531          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
532              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
533              q.poll();              assertEquals(i, q.poll());
534              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
535          }          }
536      }      }
# Line 649  Line 546 
546          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
547          q.add(one);          q.add(one);
548          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
549            assertTrue(q.contains(one));
550          q.clear();          q.clear();
551          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
552      }      }
# Line 696  Line 594 
594              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
595              assertEquals(SIZE-i, q.size());              assertEquals(SIZE-i, q.size());
596              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
597                  Integer I = (Integer)(p.remove());                  Integer x = (Integer)(p.remove());
598                  assertFalse(q.contains(I));                  assertFalse(q.contains(x));
599              }              }
600          }          }
601      }      }
602    
603      /**      void checkToArray(ArrayBlockingQueue q) {
604       *  toArray contains all elements          int size = q.size();
      */  
     public void testToArray() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
605          Object[] o = q.toArray();          Object[] o = q.toArray();
606          try {          assertEquals(size, o.length);
607          for(int i = 0; i < o.length; i++)          Iterator it = q.iterator();
608              assertEquals(o[i], q.take());          for (int i = 0; i < size; i++) {
609          } catch (InterruptedException e){              Integer x = (Integer) it.next();
610              unexpectedException();              assertEquals((Integer)o[0] + i, (int) x);
611                assertSame(o[i], x);
612          }          }
613      }      }
614    
615      /**      /**
616       * toArray(a) contains all elements       * toArray() contains all elements in FIFO order
617       */       */
618      public void testToArray2() {      public void testToArray() {
619          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
620          Integer[] ints = new Integer[SIZE];          for (int i = 0; i < SIZE; i++) {
621          ints = (Integer[])q.toArray(ints);              checkToArray(q);
622          try {              q.add(i);
623              for(int i = 0; i < ints.length; i++)          }
624                  assertEquals(ints[i], q.take());          // Provoke wraparound
625          } catch (InterruptedException e){          for (int i = 0; i < SIZE; i++) {
626              unexpectedException();              checkToArray(q);
627                assertEquals(i, q.poll());
628                checkToArray(q);
629                q.add(SIZE + i);
630            }
631            for (int i = 0; i < SIZE; i++) {
632                checkToArray(q);
633                assertEquals(SIZE + i, q.poll());
634            }
635        }
636    
637        void checkToArray2(ArrayBlockingQueue q) {
638            int size = q.size();
639            Integer[] a1 = (size == 0) ? null : new Integer[size - 1];
640            Integer[] a2 = new Integer[size];
641            Integer[] a3 = new Integer[size + 2];
642            if (size > 0) Arrays.fill(a1, 42);
643            Arrays.fill(a2, 42);
644            Arrays.fill(a3, 42);
645            Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);
646            Integer[] b2 = (Integer[]) q.toArray(a2);
647            Integer[] b3 = (Integer[]) q.toArray(a3);
648            assertSame(a2, b2);
649            assertSame(a3, b3);
650            Iterator it = q.iterator();
651            for (int i = 0; i < size; i++) {
652                Integer x = (Integer) it.next();
653                assertSame(b1[i], x);
654                assertEquals(b1[0] + i, (int) x);
655                assertSame(b2[i], x);
656                assertSame(b3[i], x);
657            }
658            assertNull(a3[size]);
659            assertEquals(42, (int) a3[size + 1]);
660            if (size > 0) {
661                assertNotSame(a1, b1);
662                assertEquals(size, b1.length);
663                for (int i = 0; i < a1.length; i++) {
664                    assertEquals(42, (int) a1[i]);
665                }
666          }          }
667      }      }
668    
669      /**      /**
670       * toArray(null) throws NPE       * toArray(a) contains all elements in FIFO order
671       */       */
672      public void testToArray_BadArg() {      public void testToArray2() {
673          try {          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
674              ArrayBlockingQueue q = populatedQueue(SIZE);          for (int i = 0; i < SIZE; i++) {
675              Object o[] = q.toArray(null);              checkToArray2(q);
676              shouldThrow();              q.add(i);
677          } catch(NullPointerException success){}          }
678            // Provoke wraparound
679            for (int i = 0; i < SIZE; i++) {
680                checkToArray2(q);
681                assertEquals(i, q.poll());
682                checkToArray2(q);
683                q.add(SIZE + i);
684            }
685            for (int i = 0; i < SIZE; i++) {
686                checkToArray2(q);
687                assertEquals(SIZE + i, q.poll());
688            }
689      }      }
690    
691      /**      /**
692       * toArray with incompatable array type throws CCE       * toArray(incompatible array type) throws ArrayStoreException
693       */       */
694      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
695              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
696              Object o[] = q.toArray(new String[10] );          try {
697                q.toArray(new String[10]);
698              shouldThrow();              shouldThrow();
699          } catch(ArrayStoreException  success){}          } catch(ArrayStoreException  success){}
700      }      }
701    
   
702      /**      /**
703       * iterator iterates through all elements       * iterator iterates through all elements
704       */       */
705      public void testIterator() {      public void testIterator() throws InterruptedException {
706          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
707          Iterator it = q.iterator();          Iterator it = q.iterator();
708          try {          int i;
709              while(it.hasNext()){          for (i = 0; it.hasNext(); i++)
710                assertTrue(q.contains(it.next()));
711            assertEquals(i, SIZE);
712            assertIteratorExhausted(it);
713    
714            it = q.iterator();
715            for (i = 0; it.hasNext(); i++)
716                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
717            assertEquals(i, SIZE);
718            assertIteratorExhausted(it);
719              }              }
720          } catch (InterruptedException e){  
721              unexpectedException();      /**
722          }       * iterator of empty collection has no elements
723         */
724        public void testEmptyIterator() {
725            assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
726      }      }
727    
728      /**      /**
# Line 783  Line 739 
739          it.remove();          it.remove();
740    
741          it = q.iterator();          it = q.iterator();
742          assertEquals(it.next(), one);          assertSame(it.next(), one);
743          assertEquals(it.next(), three);          assertSame(it.next(), three);
744          assertFalse(it.hasNext());          assertFalse(it.hasNext());
745      }      }
746    
# Line 801  Line 757 
757    
758          int k = 0;          int k = 0;
759          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
760              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
761          }          }
762          assertEquals(3, k);          assertEquals(3, k);
763      }      }
# Line 815  Line 770 
770          q.add(one);          q.add(one);
771          q.add(two);          q.add(two);
772          q.add(three);          q.add(three);
         try {  
773              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
774                  q.remove();                  q.remove();
775                  it.next();                  it.next();
776              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
777          assertEquals(0, q.size());          assertEquals(0, q.size());
778      }      }
779    
   
780      /**      /**
781       * toString contains toStrings of elements       * toString contains toStrings of elements
782       */       */
# Line 835  Line 784 
784          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
785          String s = q.toString();          String s = q.toString();
786          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
787              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
788          }          }
789      }      }
790    
   
791      /**      /**
792       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
793       */       */
# Line 847  Line 795 
795          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
796          q.add(one);          q.add(one);
797          q.add(two);          q.add(two);
798          ExecutorService executor = Executors.newFixedThreadPool(2);          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
799          executor.execute(new Runnable() {          final ExecutorService executor = Executors.newFixedThreadPool(2);
800              public void run() {          try (PoolCleaner cleaner = cleaner(executor)) {
801                  threadAssertFalse(q.offer(three));              executor.execute(new CheckedRunnable() {
802                  try {                  public void realRun() throws InterruptedException {
803                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                      assertFalse(q.offer(three));
804                      threadAssertEquals(0, q.remainingCapacity());                      threadsStarted.await();
805                  }                      assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
806                  catch (InterruptedException e) {                      assertEquals(0, q.remainingCapacity());
807                      threadUnexpectedException();                  }});
                 }  
             }  
         });  
808    
809          executor.execute(new Runnable() {              executor.execute(new CheckedRunnable() {
810              public void run() {                  public void realRun() throws InterruptedException {
811                  try {                      threadsStarted.await();
812                      Thread.sleep(SMALL_DELAY_MS);                      assertEquals(0, q.remainingCapacity());
813                      threadAssertEquals(one, q.take());                      assertSame(one, q.take());
814                  }                  }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
815              }              }
         });  
   
         joinPool(executor);  
   
816      }      }
817    
818      /**      /**
819       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
820       */       */
821      public void testPollInExecutor() {      public void testPollInExecutor() {
822          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
823          ExecutorService executor = Executors.newFixedThreadPool(2);          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
824          executor.execute(new Runnable() {          final ExecutorService executor = Executors.newFixedThreadPool(2);
825              public void run() {          try (PoolCleaner cleaner = cleaner(executor)) {
826                  threadAssertNull(q.poll());              executor.execute(new CheckedRunnable() {
827                  try {                  public void realRun() throws InterruptedException {
828                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                      assertNull(q.poll());
829                      threadAssertTrue(q.isEmpty());                      threadsStarted.await();
830                  }                      assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
831                  catch (InterruptedException e) {                      checkEmpty(q);
832                      threadUnexpectedException();                  }});
                 }  
             }  
         });  
833    
834          executor.execute(new Runnable() {              executor.execute(new CheckedRunnable() {
835              public void run() {                  public void realRun() throws InterruptedException {
836                  try {                      threadsStarted.await();
                     Thread.sleep(SMALL_DELAY_MS);  
837                      q.put(one);                      q.put(one);
838                    }});
839                  }                  }
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
   
         joinPool(executor);  
840      }      }
841    
842      /**      /**
843       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
844       */       */
845      public void testSerialization() {      public void testSerialization() throws Exception {
846          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
847            Queue y = serialClone(x);
848          try {  
849              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          assertNotSame(x, y);
850              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          assertEquals(x.size(), y.size());
851              out.writeObject(q);          assertEquals(x.toString(), y.toString());
852              out.close();          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
853            while (!x.isEmpty()) {
854              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              assertFalse(y.isEmpty());
855              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              assertEquals(x.remove(), y.remove());
             ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();  
             assertEquals(q.size(), r.size());  
             while (!q.isEmpty())  
                 assertEquals(q.remove(), r.remove());  
         } catch(Exception e){  
             unexpectedException();  
         }  
     }  
   
     /**  
      * drainTo(null) throws NPE  
      */  
     public void testDrainToNull() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(null);  
             shouldThrow();  
         } catch(NullPointerException success) {  
         }  
     }  
   
     /**  
      * drainTo(this) throws IAE  
      */  
     public void testDrainToSelf() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(q);  
             shouldThrow();  
         } catch(IllegalArgumentException success) {  
856          }          }
857            assertTrue(y.isEmpty());
858      }      }
859    
860      /**      /**
# Line 965  Line 864 
864          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
865          ArrayList l = new ArrayList();          ArrayList l = new ArrayList();
866          q.drainTo(l);          q.drainTo(l);
867          assertEquals(q.size(), 0);          assertEquals(0, q.size());
868          assertEquals(l.size(), SIZE);          assertEquals(SIZE, l.size());
869          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
870              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
871            q.add(zero);
872            q.add(one);
873            assertFalse(q.isEmpty());
874            assertTrue(q.contains(zero));
875            assertTrue(q.contains(one));
876            l.clear();
877            q.drainTo(l);
878            assertEquals(0, q.size());
879            assertEquals(2, l.size());
880            for (int i = 0; i < 2; ++i)
881                assertEquals(l.get(i), new Integer(i));
882      }      }
883    
884      /**      /**
885       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
886       */       */
887      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
888          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
889          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
890                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
891                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
892                      } catch (InterruptedException ie){              }});
893                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
894              t.start();              t.start();
895              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
896              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 898 
898              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
899                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
900              t.join();              t.join();
901              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
902      }      }
903    
904      /**      /**
905       * drainTo(null, n) throws NPE       * drainTo(c, n) empties first min(n, size) elements of queue into c
      */  
     public void testDrainToNullN() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(null, 0);  
             shouldThrow();  
         } catch(NullPointerException success) {  
         }  
     }  
   
     /**  
      * drainTo(this, n) throws IAE  
      */  
     public void testDrainToSelfN() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(q, 0);  
             shouldThrow();  
         } catch(IllegalArgumentException success) {  
         }  
     }  
   
     /**  
      * drainTo(c, n) empties first max {n, size} elements of queue into c  
906       */       */
907      public void testDrainToN() {      public void testDrainToN() {
908            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE * 2);
909          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
910              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
911                    assertTrue(q.offer(new Integer(j)));
912              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
913              q.drainTo(l, i);              q.drainTo(l, i);
914              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
915              assertEquals(q.size(), SIZE-k);              assertEquals(k, l.size());
916              assertEquals(l.size(), k);              assertEquals(SIZE - k, q.size());
917              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
918                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
919                do {} while (q.poll() != null);
920          }          }
921      }      }
922    
923        /**
924         * remove(null), contains(null) always return false
925         */
926        public void testNeverContainsNull() {
927            Collection<?>[] qs = {
928                new ArrayBlockingQueue<Object>(10),
929                populatedQueue(2),
930            };
931    
932            for (Collection<?> q : qs) {
933                assertFalse(q.contains(null));
934                assertFalse(q.remove(null));
935            }
936        }
937  }  }

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.73

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8