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

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

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

revision 1.6 by dl, Sun Oct 5 23:00:39 2003 UTC revision 1.58 by jsr166, Wed Dec 31 19:05:42 2014 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 junit.framework.*;  import java.util.ArrayList;
12  import java.util.*;  import java.util.Arrays;
13  import java.util.concurrent.*;  import java.util.Collection;
14  import java.io.*;  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.Test;
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());            junit.textui.TestRunner.run(suite());
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)));
58          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
59          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
60          assertEquals(n, q.size());          assertEquals(n, q.size());
61          return q;          return q;
62      }      }
63    
64      /**      /**
65       * A new queue has the indicated capacity       * A new queue has the indicated capacity
66       */       */
# Line 42  public class ArrayBlockingQueueTest exte Line 69  public class ArrayBlockingQueueTest exte
69      }      }
70    
71      /**      /**
72       * Constructor throws IAE if  capacity argument nonpositive       * Constructor throws IAE if capacity argument nonpositive
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  public class ArrayBlockingQueueTest exte Line 83  public class ArrayBlockingQueueTest exte
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() {
106            Integer[] ints = new Integer[SIZE];
107            for (int i = 0; i < SIZE-1; ++i)
108                ints[i] = i;
109            Collection<Integer> elements = Arrays.asList(ints);
110          try {          try {
111              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
             for (int i = 0; i < SIZE-1; ++i)  
                 ints[i] = new Integer(i);  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));  
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() {
120            Integer[] ints = new Integer[SIZE];
121            for (int i = 0; i < SIZE; ++i)
122                ints[i] = i;
123            Collection<Integer> elements = Arrays.asList(ints);
124          try {          try {
125              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE - 1, false, elements);
             for (int i = 0; i < SIZE; ++i)  
                 ints[i] = new Integer(i);  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));  
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() {
134          try {          Integer[] ints = new Integer[SIZE];
135              Integer[] ints = new Integer[SIZE];          for (int i = 0; i < SIZE; ++i)
136              for (int i = 0; i < SIZE; ++i)              ints[i] = i;
137                  ints[i] = new Integer(i);          Collection<Integer> elements = Arrays.asList(ints);
138              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));          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());
         }  
         finally {}  
141      }      }
142    
143      /**      /**
# Line 151  public class ArrayBlockingQueueTest exte Line 173  public class ArrayBlockingQueueTest exte
173      }      }
174    
175      /**      /**
      *  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) { }    
     }  
   
     /**  
176       * Offer succeeds if not full; fails if full       * Offer succeeds if not full; fails if full
177       */       */
178      public void testOffer() {      public void testOffer() {
# Line 185  public class ArrayBlockingQueueTest exte Line 185  public class ArrayBlockingQueueTest exte
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() {
188          try {          try {
189              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
190              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
191                  assertTrue(q.add(new Integer(i)));                  assertTrue(q.add(new Integer(i)));
192              }              }
193              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
194              q.add(new Integer(SIZE));              q.add(new Integer(SIZE));
         } catch (IllegalStateException success){  
         }    
     }  
   
     /**  
      *  addAll(null) throws NPE  
      */  
     public void testAddAll1() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.addAll(null);  
195              shouldThrow();              shouldThrow();
196          }          } catch (IllegalStateException success) {}
         catch (NullPointerException success) {}  
197      }      }
198    
199      /**      /**
# Line 216  public class ArrayBlockingQueueTest exte Line 204  public class ArrayBlockingQueueTest exte
204              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
205              q.addAll(q);              q.addAll(q);
206              shouldThrow();              shouldThrow();
207          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
208      }      }
209    
   
     /**  
      *  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) {}  
     }  
210      /**      /**
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
# Line 245  public class ArrayBlockingQueueTest exte Line 219  public class ArrayBlockingQueueTest exte
219                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
220              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
221              shouldThrow();              shouldThrow();
222          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
223      }      }
224    
225      /**      /**
226       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
227       */       */
# Line 259  public class ArrayBlockingQueueTest exte Line 233  public class ArrayBlockingQueueTest exte
233                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
234              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
235              shouldThrow();              shouldThrow();
236          }          } catch (IllegalStateException success) {}
         catch (IllegalStateException success) {}  
237      }      }
238    
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() {
243          try {          Integer[] empty = new Integer[0];
244              Integer[] empty = new Integer[0];          Integer[] ints = new Integer[SIZE];
245              Integer[] ints = new Integer[SIZE];          for (int i = 0; i < SIZE; ++i)
246              for (int i = 0; i < SIZE; ++i)              ints[i] = new Integer(i);
247                  ints[i] = new Integer(i);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
248              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          assertFalse(q.addAll(Arrays.asList(empty)));
249              assertFalse(q.addAll(Arrays.asList(empty)));          assertTrue(q.addAll(Arrays.asList(ints)));
250              assertTrue(q.addAll(Arrays.asList(ints)));          for (int i = 0; i < SIZE; ++i)
251              for (int i = 0; i < SIZE; ++i)              assertEquals(ints[i], q.poll());
                 assertEquals(ints[i], q.poll());  
         }  
         finally {}  
252      }      }
253    
254      /**      /**
      *  put(null) throws NPE  
      */  
      public void testPutNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
             q.put(null);  
             shouldThrow();  
         }  
         catch (NullPointerException success){  
         }    
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
      }  
   
     /**  
255       * all elements successfully put are contained       * all elements successfully put are contained
256       */       */
257       public void testPut() {      public void testPut() throws InterruptedException {
258           try {          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
259               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          for (int i = 0; i < SIZE; ++i) {
260               for (int i = 0; i < SIZE; ++i) {              Integer I = new Integer(i);
261                   Integer I = new Integer(i);              q.put(I);
262                   q.put(I);              assertTrue(q.contains(I));
                  assertTrue(q.contains(I));  
              }  
              assertEquals(0, q.remainingCapacity());  
          }  
         catch (InterruptedException ie) {  
             unexpectedException();  
263          }          }
264            assertEquals(0, q.remainingCapacity());
265      }      }
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                      try {              public void realRun() throws InterruptedException {
275                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                  for (int i = 0; i < SIZE; ++i)
276                          for (int i = 0; i < SIZE; ++i) {                      q.put(i);
277                              q.put(new Integer(i));                  assertEquals(SIZE, q.size());
278                              ++added;                  assertEquals(0, q.remainingCapacity());
279                          }  
280                          q.put(new Integer(SIZE));                  Thread.currentThread().interrupt();
281                          threadShouldThrow();                  try {
282                      } catch (InterruptedException ie){                      q.put(99);
283                          threadAssertEquals(added, SIZE);                      shouldThrow();
284                      }                    } catch (InterruptedException success) {}
285                  }});                  assertFalse(Thread.interrupted());
286          try {  
287              t.start();                  pleaseInterrupt.countDown();
288             Thread.sleep(SHORT_DELAY_MS);                  try {
289             t.interrupt();                      q.put(99);
290             t.join();                      shouldThrow();
291          }                  } catch (InterruptedException success) {}
292          catch (InterruptedException ie) {                  assertFalse(Thread.interrupted());
293              unexpectedException();              }});
294          }  
295            await(pleaseInterrupt);
296            assertThreadStaysAlive(t);
297            t.interrupt();
298            awaitTermination(t);
299            assertEquals(SIZE, q.size());
300            assertEquals(0, q.remainingCapacity());
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();
319                          ++added;                  try {
320                          threadShouldThrow();                      q.put(99);
321                      } catch (InterruptedException e){                      shouldThrow();
322                          threadAssertTrue(added >= 2);                  } catch (InterruptedException success) {}
323                      }                  assertFalse(Thread.interrupted());
324                  }              }});
325              });  
326          try {          await(pleaseTake);
327              t.start();          assertEquals(0, q.remainingCapacity());
328              Thread.sleep(SHORT_DELAY_MS);          assertEquals(0, q.take());
329              q.take();  
330              t.interrupt();          await(pleaseInterrupt);
331              t.join();          assertThreadStaysAlive(t);
332          } catch (Exception e){          t.interrupt();
333              unexpectedException();          awaitTermination(t);
334          }          assertEquals(0, q.remainingCapacity());
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                      } catch (InterruptedException success){}                  pleaseInterrupt.countDown();
351                  }                  try {
352              });                      q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
353                                shouldThrow();
354          try {                  } catch (InterruptedException success) {}
355              t.start();              }});
356              Thread.sleep(SHORT_DELAY_MS);  
357              t.interrupt();          await(pleaseInterrupt);
358              t.join();          assertThreadStaysAlive(t);
359          } catch (Exception e){          t.interrupt();
360              unexpectedException();          awaitTermination(t);
         }  
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 {
367          try {          ArrayBlockingQueue q = populatedQueue(SIZE);
368              ArrayBlockingQueue q = populatedQueue(SIZE);          for (int i = 0; i < SIZE; ++i) {
369              for (int i = 0; i < SIZE; ++i) {              assertEquals(i, q.take());
                 assertEquals(i, ((Integer)q.take()).intValue());  
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
         }    
     }  
   
     /**  
      * take blocks interruptibly when empty  
      */  
     public void testTakeFromEmpty() {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         q.take();  
                         threadShouldThrow();  
                     } catch (InterruptedException success){ }                  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         } catch (Exception e){  
             unexpectedException();  
370          }          }
371      }      }
372    
373      /**      /**
374       * Take removes existing elements until empty, then blocks interruptibly       * Take removes existing elements until empty, then blocks interruptibly
375       */       */
376      public void testBlockingTake() {      public void testBlockingTake() throws InterruptedException {
377          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = populatedQueue(SIZE);
378                  public void run() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
379                      try {          Thread t = newStartedThread(new CheckedRunnable() {
380                          ArrayBlockingQueue q = populatedQueue(SIZE);              public void realRun() throws InterruptedException {
381                          for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
382                              threadAssertEquals(i, ((Integer)q.take()).intValue());                      assertEquals(i, q.take());
383                          }                  }
                         q.take();  
                         threadShouldThrow();  
                     } catch (InterruptedException success){  
                     }    
                 }});  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
384    
385                    Thread.currentThread().interrupt();
386                    try {
387                        q.take();
388                        shouldThrow();
389                    } catch (InterruptedException success) {}
390                    assertFalse(Thread.interrupted());
391    
392                    pleaseInterrupt.countDown();
393                    try {
394                        q.take();
395                        shouldThrow();
396                    } catch (InterruptedException success) {}
397                    assertFalse(Thread.interrupted());
398                }});
399    
400            await(pleaseInterrupt);
401            assertThreadStaysAlive(t);
402            t.interrupt();
403            awaitTermination(t);
404        }
405    
406      /**      /**
407       * poll succeeds unless empty       * poll succeeds unless empty
# Line 476  public class ArrayBlockingQueueTest exte Line 409  public class ArrayBlockingQueueTest exte
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 {
421          try {          ArrayBlockingQueue q = populatedQueue(SIZE);
422              ArrayBlockingQueue q = populatedQueue(SIZE);          for (int i = 0; i < SIZE; ++i) {
423              for (int i = 0; i < SIZE; ++i) {              assertEquals(i, q.poll(0, MILLISECONDS));
424                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());          }
425              }          assertNull(q.poll(0, MILLISECONDS));
426              assertNull(q.poll(0, TimeUnit.MILLISECONDS));          checkEmpty(q);
         } catch (InterruptedException e){  
             unexpectedException();  
         }    
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 {
433          try {          ArrayBlockingQueue q = populatedQueue(SIZE);
434              ArrayBlockingQueue q = populatedQueue(SIZE);          for (int i = 0; i < SIZE; ++i) {
435              for (int i = 0; i < SIZE; ++i) {              long startTime = System.nanoTime();
436                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
437              }              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
438              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));          }
439          } catch (InterruptedException e){          long startTime = System.nanoTime();
440              unexpectedException();          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                          for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
455                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      long t0 = System.nanoTime();
456                          }                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
457                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                      assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
                     } catch (InterruptedException success){  
                     }    
                 }});  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
   
     /**  
      *  timed poll before a delayed offer fails; after offer succeeds;  
      *  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) { }                  
458                  }                  }
459              });                  long t0 = System.nanoTime();
460          try {                  aboutToWait.countDown();
461              t.start();                  try {
462              Thread.sleep(SMALL_DELAY_MS);                      q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
463              assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                      shouldThrow();
464              t.interrupt();                  } catch (InterruptedException success) {
465              t.join();                      assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
466          } catch (Exception e){                  }
467              unexpectedException();              }});
468          }  
469      }            aboutToWait.await();
470            waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
471            t.interrupt();
472            awaitTermination(t, MEDIUM_DELAY_MS);
473            checkEmpty(q);
474        }
475    
476      /**      /**
477       * peek returns next element, or null if empty       * peek returns next element, or null if empty
# Line 572  public class ArrayBlockingQueueTest exte Line 479  public class ArrayBlockingQueueTest exte
479      public void testPeek() {      public void testPeek() {
480          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
481          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
482              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
483              q.poll();              assertEquals(i, q.poll());
484              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
485                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
486          }          }
487          assertNull(q.peek());          assertNull(q.peek());
488      }      }
489    
490      /**      /**
# Line 586  public class ArrayBlockingQueueTest exte Line 493  public class ArrayBlockingQueueTest exte
493      public void testElement() {      public void testElement() {
494          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
495          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
496              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
497              q.poll();              assertEquals(i, q.poll());
498          }          }
499          try {          try {
500              q.element();              q.element();
501              shouldThrow();              shouldThrow();
502          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
503      }      }
504    
505      /**      /**
# Line 602  public class ArrayBlockingQueueTest exte Line 508  public class ArrayBlockingQueueTest exte
508      public void testRemove() {      public void testRemove() {
509          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
510          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
511              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
512          }          }
513          try {          try {
514              q.remove();              q.remove();
515              shouldThrow();              shouldThrow();
516          } catch (NoSuchElementException success){          } catch (NoSuchElementException success) {}
         }    
517      }      }
518    
519      /**      /**
      * 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());  
     }  
           
     /**  
520       * contains(x) reports true when elements added but not yet removed       * contains(x) reports true when elements added but not yet removed
521       */       */
522      public void testContains() {      public void testContains() {
523          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
524          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
525              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
526              q.poll();              assertEquals(i, q.poll());
527              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
528          }          }
529      }      }
# Line 649  public class ArrayBlockingQueueTest exte Line 539  public class ArrayBlockingQueueTest exte
539          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
540          q.add(one);          q.add(one);
541          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
542            assertTrue(q.contains(one));
543          q.clear();          q.clear();
544          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
545      }      }
# Line 702  public class ArrayBlockingQueueTest exte Line 593  public class ArrayBlockingQueueTest exte
593          }          }
594      }      }
595    
596        void checkToArray(ArrayBlockingQueue q) {
597            int size = q.size();
598            Object[] o = q.toArray();
599            assertEquals(size, o.length);
600            Iterator it = q.iterator();
601            for (int i = 0; i < size; i++) {
602                Integer x = (Integer) it.next();
603                assertEquals((Integer)o[0] + i, (int) x);
604                assertSame(o[i], x);
605            }
606        }
607    
608      /**      /**
609       *  toArray contains all elements       * toArray() contains all elements in FIFO order
610       */       */
611      public void testToArray() {      public void testToArray() {
612          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
613          Object[] o = q.toArray();          for (int i = 0; i < SIZE; i++) {
614          try {              checkToArray(q);
615          for(int i = 0; i < o.length; i++)              q.add(i);
616              assertEquals(o[i], q.take());          }
617          } catch (InterruptedException e){          // Provoke wraparound
618              unexpectedException();          for (int i = 0; i < SIZE; i++) {
619          }                  checkToArray(q);
620                assertEquals(i, q.poll());
621                checkToArray(q);
622                q.add(SIZE+i);
623            }
624            for (int i = 0; i < SIZE; i++) {
625                checkToArray(q);
626                assertEquals(SIZE+i, q.poll());
627            }
628      }      }
629    
630      /**      void checkToArray2(ArrayBlockingQueue q) {
631       * toArray(a) contains all elements          int size = q.size();
632       */          Integer[] a1 = size == 0 ? null : new Integer[size-1];
633      public void testToArray2() {          Integer[] a2 = new Integer[size];
634          ArrayBlockingQueue q = populatedQueue(SIZE);          Integer[] a3 = new Integer[size+2];
635          Integer[] ints = new Integer[SIZE];          if (size > 0) Arrays.fill(a1, 42);
636          ints = (Integer[])q.toArray(ints);          Arrays.fill(a2, 42);
637          try {          Arrays.fill(a3, 42);
638              for(int i = 0; i < ints.length; i++)          Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
639                  assertEquals(ints[i], q.take());          Integer[] b2 = (Integer[]) q.toArray(a2);
640          } catch (InterruptedException e){          Integer[] b3 = (Integer[]) q.toArray(a3);
641              unexpectedException();          assertSame(a2, b2);
642          }              assertSame(a3, b3);
643            Iterator it = q.iterator();
644            for (int i = 0; i < size; i++) {
645                Integer x = (Integer) it.next();
646                assertSame(b1[i], x);
647                assertEquals(b1[0] + i, (int) x);
648                assertSame(b2[i], x);
649                assertSame(b3[i], x);
650            }
651            assertNull(a3[size]);
652            assertEquals(42, (int) a3[size+1]);
653            if (size > 0) {
654                assertNotSame(a1, b1);
655                assertEquals(size, b1.length);
656                for (int i = 0; i < a1.length; i++) {
657                    assertEquals(42, (int) a1[i]);
658                }
659            }
660      }      }
661    
662      /**      /**
663       * toArray(null) throws NPE       * toArray(a) contains all elements in FIFO order
664       */       */
665      public void testToArray_BadArg() {      public void testToArray2() {
666          try {          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
667              ArrayBlockingQueue q = populatedQueue(SIZE);          for (int i = 0; i < SIZE; i++) {
668              Object o[] = q.toArray(null);              checkToArray2(q);
669              shouldThrow();              q.add(i);
670          } catch(NullPointerException success){}          }
671            // Provoke wraparound
672            for (int i = 0; i < SIZE; i++) {
673                checkToArray2(q);
674                assertEquals(i, q.poll());
675                checkToArray2(q);
676                q.add(SIZE+i);
677            }
678            for (int i = 0; i < SIZE; i++) {
679                checkToArray2(q);
680                assertEquals(SIZE+i, q.poll());
681            }
682      }      }
683    
684      /**      /**
685       * toArray with incompatable array type throws CCE       * toArray(incompatible array type) throws ArrayStoreException
686       */       */
687      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
688          try {          ArrayBlockingQueue q = populatedQueue(SIZE);
689              ArrayBlockingQueue q = populatedQueue(SIZE);          try {
690              Object o[] = q.toArray(new String[10] );              q.toArray(new String[10]);
691              shouldThrow();              shouldThrow();
692          } catch(ArrayStoreException  success){}          } catch (ArrayStoreException success) {}
693      }      }
694    
       
695      /**      /**
696       * iterator iterates through all elements       * iterator iterates through all elements
697       */       */
698      public void testIterator() {      public void testIterator() throws InterruptedException {
699          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
700          Iterator it = q.iterator();          Iterator it = q.iterator();
701          try {          while (it.hasNext()) {
702              while(it.hasNext()){              assertEquals(it.next(), q.take());
703                  assertEquals(it.next(), q.take());          }
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
         }      
704      }      }
705    
706      /**      /**
707       * iterator.remove removes current element       * iterator.remove removes current element
708       */       */
709      public void testIteratorRemove () {      public void testIteratorRemove() {
710          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
711          q.add(two);          q.add(two);
712          q.add(one);          q.add(one);
# Line 781  public class ArrayBlockingQueueTest exte Line 715  public class ArrayBlockingQueueTest exte
715          Iterator it = q.iterator();          Iterator it = q.iterator();
716          it.next();          it.next();
717          it.remove();          it.remove();
718            
719          it = q.iterator();          it = q.iterator();
720          assertEquals(it.next(), one);          assertSame(it.next(), one);
721          assertEquals(it.next(), three);          assertSame(it.next(), three);
722          assertFalse(it.hasNext());          assertFalse(it.hasNext());
723      }      }
724    
# Line 801  public class ArrayBlockingQueueTest exte Line 735  public class ArrayBlockingQueueTest exte
735    
736          int k = 0;          int k = 0;
737          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
738              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
739          }          }
740          assertEquals(3, k);          assertEquals(3, k);
741      }      }
# Line 810  public class ArrayBlockingQueueTest exte Line 743  public class ArrayBlockingQueueTest exte
743      /**      /**
744       * Modifications do not cause iterators to fail       * Modifications do not cause iterators to fail
745       */       */
746      public void testWeaklyConsistentIteration () {      public void testWeaklyConsistentIteration() {
747          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
748          q.add(one);          q.add(one);
749          q.add(two);          q.add(two);
750          q.add(three);          q.add(three);
751          try {          for (Iterator it = q.iterator(); it.hasNext();) {
752              for (Iterator it = q.iterator(); it.hasNext();) {              q.remove();
753                  q.remove();              it.next();
                 it.next();  
             }  
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
754          }          }
755          assertEquals(0, q.size());          assertEquals(0, q.size());
756      }      }
757    
   
758      /**      /**
759       * toString contains toStrings of elements       * toString contains toStrings of elements
760       */       */
# Line 835  public class ArrayBlockingQueueTest exte Line 762  public class ArrayBlockingQueueTest exte
762          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
763          String s = q.toString();          String s = q.toString();
764          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
765              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
766          }          }
767      }              }
   
768    
769      /**      /**
770       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
# Line 848  public class ArrayBlockingQueueTest exte Line 774  public class ArrayBlockingQueueTest exte
774          q.add(one);          q.add(one);
775          q.add(two);          q.add(two);
776          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
777          executor.execute(new Runnable() {          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
778              public void run() {          executor.execute(new CheckedRunnable() {
779                  threadAssertFalse(q.offer(three));              public void realRun() throws InterruptedException {
780                  try {                  assertFalse(q.offer(three));
781                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  threadsStarted.await();
782                      threadAssertEquals(0, q.remainingCapacity());                  assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
783                  }                  assertEquals(0, q.remainingCapacity());
784                  catch (InterruptedException e) {              }});
785                      threadUnexpectedException();  
786                  }          executor.execute(new CheckedRunnable() {
787              }              public void realRun() throws InterruptedException {
788          });                  threadsStarted.await();
789                    assertEquals(0, q.remainingCapacity());
790                    assertSame(one, q.take());
791                }});
792    
         executor.execute(new Runnable() {  
             public void run() {  
                 try {  
                     Thread.sleep(SMALL_DELAY_MS);  
                     threadAssertEquals(one, q.take());  
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
           
793          joinPool(executor);          joinPool(executor);
   
794      }      }
795    
796      /**      /**
797       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
798       */       */
799      public void testPollInExecutor() {      public void testPollInExecutor() {
800          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
801            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
802          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
803          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
804              public void run() {              public void realRun() throws InterruptedException {
805                  threadAssertNull(q.poll());                  assertNull(q.poll());
806                  try {                  threadsStarted.await();
807                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
808                      threadAssertTrue(q.isEmpty());                  checkEmpty(q);
809                  }              }});
810                  catch (InterruptedException e) {  
811                      threadUnexpectedException();          executor.execute(new CheckedRunnable() {
812                  }              public void realRun() throws InterruptedException {
813              }                  threadsStarted.await();
814          });                  q.put(one);
815                }});
816    
         executor.execute(new Runnable() {  
             public void run() {  
                 try {  
                     Thread.sleep(SMALL_DELAY_MS);  
                     q.put(one);  
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
           
817          joinPool(executor);          joinPool(executor);
818      }      }
819    
820      /**      /**
821       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
822       */       */
823      public void testSerialization() {      public void testSerialization() throws Exception {
824          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
825            Queue y = serialClone(x);
826          try {  
827              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          assertNotSame(x, y);
828              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          assertEquals(x.size(), y.size());
829              out.writeObject(q);          assertEquals(x.toString(), y.toString());
830              out.close();          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
831            while (!x.isEmpty()) {
832              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              assertFalse(y.isEmpty());
833              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) {  
834          }          }
835            assertTrue(y.isEmpty());
836      }      }
837    
838      /**      /**
839       * drainTo(c) empties queue into another collection c       * drainTo(c) empties queue into another collection c
840       */       */
841      public void testDrainTo() {      public void testDrainTo() {
842          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
843          ArrayList l = new ArrayList();          ArrayList l = new ArrayList();
844          q.drainTo(l);          q.drainTo(l);
845          assertEquals(q.size(), 0);          assertEquals(0, q.size());
846          assertEquals(l.size(), SIZE);          assertEquals(SIZE, l.size());
847          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
848                assertEquals(l.get(i), new Integer(i));
849            q.add(zero);
850            q.add(one);
851            assertFalse(q.isEmpty());
852            assertTrue(q.contains(zero));
853            assertTrue(q.contains(one));
854            l.clear();
855            q.drainTo(l);
856            assertEquals(0, q.size());
857            assertEquals(2, l.size());
858            for (int i = 0; i < 2; ++i)
859              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
860      }      }
861    
862      /**      /**
863       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
864       */       */
865      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
866          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
867          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
868                  public void run() {              public void realRun() throws InterruptedException {
869                      try {                  q.put(new Integer(SIZE+1));
870                          q.put(new Integer(SIZE+1));              }});
                     } catch (InterruptedException ie){  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
             t.start();  
             ArrayList l = new ArrayList();  
             q.drainTo(l);  
             assertTrue(l.size() >= SIZE);  
             for (int i = 0; i < SIZE; ++i)  
                 assertEquals(l.get(i), new Integer(i));  
             t.join();  
             assertTrue(q.size() + l.size() == SIZE+1);  
         } catch(Exception e){  
             unexpectedException();  
         }  
     }  
871    
872      /**          t.start();
873       * drainTo(null, n) throws NPE          ArrayList l = new ArrayList();
874       */          q.drainTo(l);
875      public void testDrainToNullN() {          assertTrue(l.size() >= SIZE);
876          ArrayBlockingQueue q = populatedQueue(SIZE);          for (int i = 0; i < SIZE; ++i)
877          try {              assertEquals(l.get(i), new Integer(i));
878              q.drainTo(null, 0);          t.join();
879              shouldThrow();          assertTrue(q.size() + l.size() >= SIZE);
         } catch(NullPointerException success) {  
         }  
     }  
   
     /**  
      * drainTo(this, n) throws IAE  
      */  
     public void testDrainToSelfN() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(q, 0);  
             shouldThrow();  
         } catch(IllegalArgumentException success) {  
         }  
880      }      }
881    
882      /**      /**
883       * 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
884       */       */
885      public void testDrainToN() {      public void testDrainToN() {
886            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
887          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
888              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
889                    assertTrue(q.offer(new Integer(j)));
890              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
891              q.drainTo(l, i);              q.drainTo(l, i);
892              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE) ? i : SIZE;
893              assertEquals(q.size(), SIZE-k);              assertEquals(k, l.size());
894              assertEquals(l.size(), k);              assertEquals(SIZE-k, q.size());
895              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
896                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
897                while (q.poll() != null) ;
898          }          }
899      }      }
900    
901        /**
902         * remove(null), contains(null) always return false
903         */
904        public void testNeverContainsNull() {
905            Collection<?>[] qs = {
906                new ArrayBlockingQueue<Object>(10),
907                populatedQueue(2),
908            };
909    
910            for (Collection<?> q : qs) {
911                assertFalse(q.contains(null));
912                assertFalse(q.remove(null));
913            }
914        }
915  }  }

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

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27