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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8