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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8