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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8