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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8