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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8