[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.88, Sun May 14 01:30:34 2017 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.Collections;
15    import java.util.Iterator;
16    import java.util.NoSuchElementException;
17    import java.util.Queue;
18    import java.util.concurrent.ArrayBlockingQueue;
19    import java.util.concurrent.BlockingQueue;
20    import java.util.concurrent.CountDownLatch;
21    import java.util.concurrent.Executors;
22    import java.util.concurrent.ExecutorService;
23    import java.util.concurrent.ThreadLocalRandom;
24    
25  import junit.framework.*;  import junit.framework.Test;
 import java.util.*;  
 import java.util.concurrent.*;  
 import java.io.*;  
26    
27  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
28    
29      public static void main(String[] args) {      public static void main(String[] args) {
30          junit.textui.TestRunner.run (suite());          main(suite(), args);
31      }      }
32    
33      public static Test suite() {      public static Test suite() {
34          return new TestSuite(ArrayBlockingQueueTest.class);          class Implementation implements CollectionImplementation {
35                public Class<?> klazz() { return ArrayBlockingQueue.class; }
36                public Collection emptyCollection() {
37                    boolean fair = ThreadLocalRandom.current().nextBoolean();
38                    return populatedQueue(0, SIZE, 2 * SIZE, fair);
39                }
40                public Object makeElement(int i) { return i; }
41                public boolean isConcurrent() { return true; }
42                public boolean permitsNulls() { return false; }
43            }
44    
45            return newTestSuite(
46                ArrayBlockingQueueTest.class,
47                new Fair().testSuite(),
48                new NonFair().testSuite(),
49                CollectionTest.testSuite(new Implementation()));
50        }
51    
52        public static class Fair extends BlockingQueueTest {
53            protected BlockingQueue emptyCollection() {
54                return populatedQueue(0, SIZE, 2 * SIZE, true);
55            }
56        }
57    
58        public static class NonFair extends BlockingQueueTest {
59            protected BlockingQueue emptyCollection() {
60                return populatedQueue(0, SIZE, 2 * SIZE, false);
61            }
62        }
63    
64        /**
65         * Returns a new queue of given size containing consecutive
66         * Integers 0 ... n - 1.
67         */
68        static ArrayBlockingQueue<Integer> populatedQueue(int n) {
69            return populatedQueue(n, n, n, false);
70      }      }
71    
72      /**      /**
73       * Create a queue of given size containing consecutive       * Returns a new queue of given size containing consecutive
74       * Integers 0 ... n.       * Integers 0 ... n - 1, with given capacity range and fairness.
75       */       */
76      private ArrayBlockingQueue populatedQueue(int n) {      static ArrayBlockingQueue<Integer> populatedQueue(
77          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          int size, int minCapacity, int maxCapacity, boolean fair) {
78            ThreadLocalRandom rnd = ThreadLocalRandom.current();
79            int capacity = rnd.nextInt(minCapacity, maxCapacity + 1);
80            ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
81          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
82          for(int i = 0; i < n; i++)          // shuffle circular array elements so they wrap
83              assertTrue(q.offer(new Integer(i)));          {
84          assertFalse(q.isEmpty());              int n = rnd.nextInt(capacity);
85          assertEquals(0, q.remainingCapacity());              for (int i = 0; i < n; i++) q.add(42);
86          assertEquals(n, q.size());              for (int i = 0; i < n; i++) q.remove();
87            }
88            for (int i = 0; i < size; i++)
89                assertTrue(q.offer((Integer) i));
90            assertEquals(size == 0, q.isEmpty());
91            assertEquals(capacity - size, q.remainingCapacity());
92            assertEquals(size, q.size());
93            if (size > 0)
94                assertEquals((Integer) 0, q.peek());
95          return q;          return q;
96      }      }
97    
# Line 44  Line 105 
105      /**      /**
106       * Constructor throws IAE if  capacity argument nonpositive       * Constructor throws IAE if  capacity argument nonpositive
107       */       */
108      public void testConstructor2() {      public void testConstructor_nonPositiveCapacity() {
109            for (int i : new int[] { 0, -1, Integer.MIN_VALUE }) {
110          try {          try {
111              ArrayBlockingQueue q = new ArrayBlockingQueue(0);                  new ArrayBlockingQueue(i);
112              shouldThrow();              shouldThrow();
113                } catch (IllegalArgumentException success) {}
114                for (boolean fair : new boolean[] { true, false }) {
115                    try {
116                        new ArrayBlockingQueue(i, fair);
117                        shouldThrow();
118                    } catch (IllegalArgumentException success) {}
119                }
120          }          }
         catch (IllegalArgumentException success) {}  
121      }      }
122    
123      /**      /**
124       * Initializing from null Collection throws NPE       * Initializing from null Collection throws NPE
125       */       */
126      public void testConstructor3() {      public void testConstructor_nullCollection() {
127          try {          try {
128              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              new ArrayBlockingQueue(1, true, null);
129              shouldThrow();              shouldThrow();
130          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
131      }      }
132    
133      /**      /**
134       * Initializing from Collection of null elements throws NPE       * Initializing from Collection of null elements throws NPE
135       */       */
136      public void testConstructor4() {      public void testConstructor4() {
137            Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
138          try {          try {
139              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE, false, elements);
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));  
140              shouldThrow();              shouldThrow();
141          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
142      }      }
143    
144      /**      /**
145       * Initializing from Collection with some null elements throws NPE       * Initializing from Collection with some null elements throws NPE
146       */       */
147      public void testConstructor5() {      public void testConstructor5() {
         try {  
148              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
149              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
150                  ints[i] = new Integer(i);              ints[i] = i;
151              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
152            try {
153                new ArrayBlockingQueue(SIZE, false, elements);
154              shouldThrow();              shouldThrow();
155          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
156      }      }
157    
158      /**      /**
159       * Initializing from too large collection throws IAE       * Initializing from too large collection throws IAE
160       */       */
161      public void testConstructor6() {      public void testConstructor_collectionTooLarge() {
162            // just barely fits - succeeds
163            new ArrayBlockingQueue(SIZE, false,
164                                   Collections.nCopies(SIZE, ""));
165          try {          try {
166              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE - 1, false,
167              for (int i = 0; i < SIZE; ++i)                                     Collections.nCopies(SIZE, ""));
                 ints[i] = new Integer(i);  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));  
168              shouldThrow();              shouldThrow();
169          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
170      }      }
171    
172      /**      /**
173       * Queue contains all elements of collection used to initialize       * Queue contains all elements of collection used to initialize
174       */       */
175      public void testConstructor7() {      public void testConstructor7() {
         try {  
176              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
177              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
178                  ints[i] = new Integer(i);              ints[i] = i;
179              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
180            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
181              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
182                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
183          }          }
         finally {}  
     }  
184    
185      /**      /**
186       * Queue transitions from empty to full when elements added       * Queue transitions from empty to full when elements added
187       */       */
188      public void testEmptyFull() {      public void testEmptyFull() {
189          ArrayBlockingQueue q = new ArrayBlockingQueue(2);          BlockingQueue q = populatedQueue(0, 2, 2, false);
190          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
191          assertEquals(2, q.remainingCapacity());          assertEquals(2, q.remainingCapacity());
192          q.add(one);          q.add(one);
193          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
194          q.add(two);          assertTrue(q.offer(two));
195          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
196          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
197          assertFalse(q.offer(three));          assertFalse(q.offer(three));
# Line 137  Line 201 
201       * remainingCapacity decreases on add, increases on remove       * remainingCapacity decreases on add, increases on remove
202       */       */
203      public void testRemainingCapacity() {      public void testRemainingCapacity() {
204          ArrayBlockingQueue q = populatedQueue(SIZE);          int size = ThreadLocalRandom.current().nextInt(1, SIZE);
205          for (int i = 0; i < SIZE; ++i) {          BlockingQueue q = populatedQueue(size, size, 2 * size, false);
206              assertEquals(i, q.remainingCapacity());          int spare = q.remainingCapacity();
207              assertEquals(SIZE-i, q.size());          int capacity = spare + size;
208              q.remove();          for (int i = 0; i < size; i++) {
209                assertEquals(spare + i, q.remainingCapacity());
210                assertEquals(capacity, q.size() + q.remainingCapacity());
211                assertEquals(i, q.remove());
212            }
213            for (int i = 0; i < size; i++) {
214                assertEquals(capacity - i, q.remainingCapacity());
215                assertEquals(capacity, q.size() + q.remainingCapacity());
216                assertTrue(q.add(i));
217          }          }
         for (int i = 0; i < SIZE; ++i) {  
             assertEquals(SIZE-i, q.remainingCapacity());  
             assertEquals(i, q.size());  
             q.add(new Integer(i));  
         }  
     }  
   
     /**  
      *  offer(null) throws NPE  
      */  
     public void testOfferNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.offer(null);  
             shouldThrow();  
         } catch (NullPointerException success) { }  
     }  
   
     /**  
      *  add(null) throws NPE  
      */  
     public void testAddNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.add(null);  
             shouldThrow();  
         } catch (NullPointerException success) { }  
218      }      }
219    
220      /**      /**
# Line 185  Line 230 
230       * add succeeds if not full; throws ISE if full       * add succeeds if not full; throws ISE if full
231       */       */
232      public void testAdd() {      public void testAdd() {
         try {  
233              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
234              for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) assertTrue(q.add((Integer) i));
                 assertTrue(q.add(new Integer(i)));  
             }  
235              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
             q.add(new Integer(SIZE));  
         } catch (IllegalStateException success){  
         }  
     }  
   
     /**  
      *  addAll(null) throws NPE  
      */  
     public void testAddAll1() {  
236          try {          try {
237              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              q.add((Integer) SIZE);
             q.addAll(null);  
238              shouldThrow();              shouldThrow();
239          }          } catch (IllegalStateException success) {}
         catch (NullPointerException success) {}  
240      }      }
241    
242      /**      /**
243       * addAll(this) throws IAE       * addAll(this) throws IAE
244       */       */
245      public void testAddAllSelf() {      public void testAddAllSelf() {
         try {  
246              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
247            try {
248              q.addAll(q);              q.addAll(q);
249              shouldThrow();              shouldThrow();
250          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
251      }      }
252    
   
     /**  
      *  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) {}  
     }  
253      /**      /**
254       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
255       * possibly adding some elements       * possibly adding some elements
256       */       */
257      public void testAddAll3() {      public void testAddAll3() {
         try {  
258              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
259              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
260              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
261                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
262            try {
263              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
264              shouldThrow();              shouldThrow();
265            } catch (NullPointerException success) {}
266          }          }
267          catch (NullPointerException success) {}  
     }  
268      /**      /**
269       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
270       */       */
271      public void testAddAll4() {      public void testAddAll_insufficientSpace() {
272            int size = ThreadLocalRandom.current().nextInt(1, SIZE);
273            ArrayBlockingQueue q = populatedQueue(0, size, size, false);
274            // Just fits:
275            q.addAll(populatedQueue(size, size, 2 * size, false));
276            assertEquals(0, q.remainingCapacity());
277            assertEquals(size, q.size());
278            assertEquals(0, q.peek());
279          try {          try {
280              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              q = populatedQueue(0, size, size, false);
281              Integer[] ints = new Integer[SIZE];              q.addAll(Collections.nCopies(size + 1, 42));
             for (int i = 0; i < SIZE; ++i)  
                 ints[i] = new Integer(i);  
             q.addAll(Arrays.asList(ints));  
282              shouldThrow();              shouldThrow();
283            } catch (IllegalStateException success) {}
284          }          }
285          catch (IllegalStateException success) {}  
     }  
286      /**      /**
287       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
288       */       */
289      public void testAddAll5() {      public void testAddAll5() {
         try {  
290              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
291              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
292              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 277  Line 297 
297              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
298                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
299          }          }
         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();  
         }  
      }  
300    
301      /**      /**
302       * all elements successfully put are contained       * all elements successfully put are contained
303       */       */
304       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
305               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
306               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
307                   Integer I = new Integer(i);              Integer x = new Integer(i);
308                   q.put(I);              q.put(x);
309                   assertTrue(q.contains(I));              assertTrue(q.contains(x));
310               }               }
311               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
312           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
313    
314      /**      /**
315       * put blocks interruptibly if full       * put blocks interruptibly if full
316       */       */
317      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
318          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
319                  public void run() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
320                      int added = 0;          Thread t = newStartedThread(new CheckedRunnable() {
321                public void realRun() throws InterruptedException {
322                    for (int i = 0; i < SIZE; ++i)
323                        q.put(i);
324                    assertEquals(SIZE, q.size());
325                    assertEquals(0, q.remainingCapacity());
326    
327                    Thread.currentThread().interrupt();
328                      try {                      try {
329                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                      q.put(99);
330                          for (int i = 0; i < SIZE; ++i) {                      shouldThrow();
331                              q.put(new Integer(i));                  } catch (InterruptedException success) {}
332                              ++added;                  assertFalse(Thread.interrupted());
333                          }  
334                          q.put(new Integer(SIZE));                  pleaseInterrupt.countDown();
                         threadShouldThrow();  
                     } catch (InterruptedException ie){  
                         threadAssertEquals(added, SIZE);  
                     }  
                 }});  
335          try {          try {
336              t.start();                      q.put(99);
337             Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
338                    } catch (InterruptedException success) {}
339                    assertFalse(Thread.interrupted());
340                }});
341    
342            await(pleaseInterrupt);
343            assertThreadBlocks(t, Thread.State.WAITING);
344             t.interrupt();             t.interrupt();
345             t.join();          awaitTermination(t);
346          }          assertEquals(SIZE, q.size());
347          catch (InterruptedException ie) {          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
348      }      }
349    
350      /**      /**
351       * put blocks waiting for take when full       * put blocks interruptibly waiting for take when full
352       */       */
353      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
354          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
355          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
356                  public void run() {          final CountDownLatch pleaseTake = new CountDownLatch(1);
357                      int added = 0;          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
358                      try {          Thread t = newStartedThread(new CheckedRunnable() {
359                          q.put(new Object());              public void realRun() throws InterruptedException {
360                          ++added;                  for (int i = 0; i < capacity; i++)
361                          q.put(new Object());                      q.put(i);
362                          ++added;                  pleaseTake.countDown();
363                          q.put(new Object());                  q.put(86);
364                          ++added;  
365                          q.put(new Object());                  pleaseInterrupt.countDown();
                         ++added;  
                         threadShouldThrow();  
                     } catch (InterruptedException e){  
                         threadAssertTrue(added >= 2);  
                     }  
                 }  
             });  
366          try {          try {
367              t.start();                      q.put(99);
368              Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
369              q.take();                  } catch (InterruptedException success) {}
370                    assertFalse(Thread.interrupted());
371                }});
372    
373            await(pleaseTake);
374            assertEquals(0, q.remainingCapacity());
375            assertEquals(0, q.take());
376    
377            await(pleaseInterrupt);
378            assertThreadBlocks(t, Thread.State.WAITING);
379              t.interrupt();              t.interrupt();
380              t.join();          awaitTermination(t);
381          } catch (Exception e){          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
382      }      }
383    
384      /**      /**
385       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
386       */       */
387      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
388          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
389          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
390                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
391                      try {              public void realRun() throws InterruptedException {
392                          q.put(new Object());                          q.put(new Object());
393                          q.put(new Object());                          q.put(new Object());
394                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  long startTime = System.nanoTime();
395                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
396                          threadShouldThrow();                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
397                    pleaseInterrupt.countDown();
398                    try {
399                        q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
400                        shouldThrow();
401                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
402                  }                  assertFalse(Thread.interrupted());
403              });              }});
404    
405          try {          await(pleaseInterrupt);
406              t.start();          assertThreadBlocks(t, Thread.State.TIMED_WAITING);
             Thread.sleep(SHORT_DELAY_MS);  
407              t.interrupt();              t.interrupt();
408              t.join();          awaitTermination(t);
         } catch (Exception e){  
             unexpectedException();  
         }  
409      }      }
410    
411      /**      /**
412       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
413       */       */
414      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
415              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
416              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
417                  assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
418          }          }
419      }      }
420    
421      /**      /**
422       * take blocks interruptibly when empty       * Take removes existing elements until empty, then blocks interruptibly
423       */       */
424      public void testTakeFromEmpty() {      public void testBlockingTake() throws InterruptedException {
425          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = populatedQueue(SIZE);
426          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
427                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
428                public void realRun() throws InterruptedException {
429                    for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
430    
431                    Thread.currentThread().interrupt();
432                      try {                      try {
433                          q.take();                          q.take();
434                          threadShouldThrow();                      shouldThrow();
435                      } catch (InterruptedException success){ }                      } catch (InterruptedException success){ }
436                  }                  assertFalse(Thread.interrupted());
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         } catch (Exception e){  
             unexpectedException();  
         }  
     }  
437    
438      /**                  pleaseInterrupt.countDown();
      * Take removes existing elements until empty, then blocks interruptibly  
      */  
     public void testBlockingTake() {  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
439                      try {                      try {
                         ArrayBlockingQueue q = populatedQueue(SIZE);  
                         for (int i = 0; i < SIZE; ++i) {  
                             threadAssertEquals(i, ((Integer)q.take()).intValue());  
                         }  
440                          q.take();                          q.take();
441                          threadShouldThrow();                      shouldThrow();
442                      } catch (InterruptedException success){                  } catch (InterruptedException success) {}
443                      }                  assertFalse(Thread.interrupted());
444                  }});                  }});
445          try {  
446              t.start();          await(pleaseInterrupt);
447              Thread.sleep(SHORT_DELAY_MS);          assertThreadBlocks(t, Thread.State.WAITING);
448              t.interrupt();              t.interrupt();
449              t.join();          awaitTermination(t);
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
450          }          }
     }  
   
451    
452      /**      /**
453       * poll succeeds unless empty       * poll succeeds unless empty
# Line 476  Line 455 
455      public void testPoll() {      public void testPoll() {
456          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
457          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
458              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
459          }          }
460          assertNull(q.poll());          assertNull(q.poll());
461      }      }
462    
463      /**      /**
464       * timed pool with zero timeout succeeds when non-empty, else times out       * timed poll with zero timeout succeeds when non-empty, else times out
465       */       */
466      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
467              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
468              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
469                  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();  
470          }          }
471            assertNull(q.poll(0, MILLISECONDS));
472            checkEmpty(q);
473      }      }
474    
475      /**      /**
476       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed poll with nonzero timeout succeeds when non-empty, else times out
477       */       */
478      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
479              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
480              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
481                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());              long startTime = System.nanoTime();
482              }              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
483              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
         } catch (InterruptedException e){  
             unexpectedException();  
484          }          }
485            long startTime = System.nanoTime();
486            assertNull(q.poll(timeoutMillis(), MILLISECONDS));
487            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
488            checkEmpty(q);
489      }      }
490    
491      /**      /**
492       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
493       * returning timeout status       * returning timeout status
494       */       */
495      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
496          Thread t = new Thread(new Runnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
497                  public void run() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
498                      try {          Thread t = newStartedThread(new CheckedRunnable() {
499                          ArrayBlockingQueue q = populatedQueue(SIZE);              public void realRun() throws InterruptedException {
500                          for (int i = 0; i < SIZE; ++i) {                  long startTime = System.nanoTime();
501                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                  for (int i = 0; i < SIZE; i++)
502                          }                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
                         threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
                     } catch (InterruptedException success){  
                     }  
                 }});  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
503    
504      /**                  Thread.currentThread().interrupt();
      *  timed poll before a delayed offer fails; after offer succeeds;  
      *  on interruption throws  
      */  
     public void testTimedPollWithOffer() {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
505                      try {                      try {
506                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                      q.poll(LONG_DELAY_MS, MILLISECONDS);
507                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                      shouldThrow();
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);  
                         threadShouldThrow();  
508                      } catch (InterruptedException success) { }                      } catch (InterruptedException success) { }
509                  }                  assertFalse(Thread.interrupted());
510              });  
511                    pleaseInterrupt.countDown();
512          try {          try {
513              t.start();                      q.poll(LONG_DELAY_MS, MILLISECONDS);
514              Thread.sleep(SMALL_DELAY_MS);                      shouldThrow();
515              assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                  } catch (InterruptedException success) {}
516                    assertFalse(Thread.interrupted());
517    
518                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
519                }});
520    
521            await(pleaseInterrupt);
522            assertThreadBlocks(t, Thread.State.TIMED_WAITING);
523              t.interrupt();              t.interrupt();
524              t.join();          awaitTermination(t);
525          } catch (Exception e){          checkEmpty(q);
             unexpectedException();  
         }  
526      }      }
527    
   
528      /**      /**
529       * peek returns next element, or null if empty       * peek returns next element, or null if empty
530       */       */
531      public void testPeek() {      public void testPeek() {
532          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
533          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
534              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
535              q.poll();              assertEquals(i, q.poll());
536              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
537                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
538          }          }
539          assertNull(q.peek());          assertNull(q.peek());
540      }      }
# Line 586  Line 545 
545      public void testElement() {      public void testElement() {
546          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
547          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
548              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
549              q.poll();              assertEquals(i, q.poll());
550          }          }
551          try {          try {
552              q.element();              q.element();
553              shouldThrow();              shouldThrow();
554          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
555      }      }
556    
557      /**      /**
# Line 602  Line 560 
560      public void testRemove() {      public void testRemove() {
561          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
562          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
563              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
564          }          }
565          try {          try {
566              q.remove();              q.remove();
567              shouldThrow();              shouldThrow();
568          } 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());  
569      }      }
570    
571      /**      /**
572       * contains(x) reports true when elements added but not yet removed       * contains(x) reports true when elements added but not yet removed
573       */       */
574      public void testContains() {      public void testContains() {
575          ArrayBlockingQueue q = populatedQueue(SIZE);          int size = ThreadLocalRandom.current().nextInt(1, SIZE);
576          for (int i = 0; i < SIZE; ++i) {          ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
577            assertFalse(q.contains(null));
578            for (int i = 0; i < size; ++i) {
579              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
580              q.poll();              assertEquals(i, q.poll());
581              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
582          }          }
583      }      }
# Line 642  Line 586 
586       * clear removes all elements       * clear removes all elements
587       */       */
588      public void testClear() {      public void testClear() {
589          ArrayBlockingQueue q = populatedQueue(SIZE);          int size = ThreadLocalRandom.current().nextInt(1, 5);
590            ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
591            int capacity = size + q.remainingCapacity();
592          q.clear();          q.clear();
593          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
594          assertEquals(0, q.size());          assertEquals(0, q.size());
595          assertEquals(SIZE, q.remainingCapacity());          assertEquals(capacity, q.remainingCapacity());
596          q.add(one);          q.add(one);
597          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
598            assertTrue(q.contains(one));
599          q.clear();          q.clear();
600          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
601      }      }
# Line 696  Line 643 
643              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
644              assertEquals(SIZE-i, q.size());              assertEquals(SIZE-i, q.size());
645              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
646                  Integer I = (Integer)(p.remove());                  Integer x = (Integer)(p.remove());
647                  assertFalse(q.contains(I));                  assertFalse(q.contains(x));
648              }              }
649          }          }
650      }      }
651    
652      /**      void checkToArray(ArrayBlockingQueue<Integer> q) {
653       *  toArray contains all elements          int size = q.size();
654       */          Object[] a1 = q.toArray();
655      public void testToArray() {          assertEquals(size, a1.length);
656          ArrayBlockingQueue q = populatedQueue(SIZE);          Integer[] a2 = q.toArray(new Integer[0]);
657          Object[] o = q.toArray();          assertEquals(size, a2.length);
658          try {          Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
659          for(int i = 0; i < o.length; i++)          assertEquals(size, a3.length);
660              assertEquals(o[i], q.take());          Integer[] a4 = new Integer[size];
661          } catch (InterruptedException e){          assertSame(a4, q.toArray(a4));
662              unexpectedException();          Integer[] a5 = new Integer[size + 1];
663            Arrays.fill(a5, 42);
664            assertSame(a5, q.toArray(a5));
665            Integer[] a6 = new Integer[size + 2];
666            Arrays.fill(a6, 42);
667            assertSame(a6, q.toArray(a6));
668            Object[][] as = { a1, a2, a3, a4, a5, a6 };
669            for (Object[] a : as) {
670                if (a.length > size) assertNull(a[size]);
671                if (a.length > size + 1) assertEquals(42, a[size + 1]);
672            }
673            Iterator it = q.iterator();
674            Integer s = q.peek();
675            for (int i = 0; i < size; i++) {
676                Integer x = (Integer) it.next();
677                assertEquals(s + i, (int) x);
678                for (Object[] a : as)
679                    assertSame(a1[i], x);
680          }          }
681      }      }
682    
683      /**      /**
684       * toArray(a) contains all elements       * toArray() and toArray(a) contain all elements in FIFO order
685       */       */
686      public void testToArray2() {      public void testToArray() {
687          ArrayBlockingQueue q = populatedQueue(SIZE);          final ThreadLocalRandom rnd = ThreadLocalRandom.current();
688          Integer[] ints = new Integer[SIZE];          final int size = rnd.nextInt(6);
689          ints = (Integer[])q.toArray(ints);          final int capacity = Math.max(1, size + rnd.nextInt(size + 1));
690          try {          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
691              for(int i = 0; i < ints.length; i++)          for (int i = 0; i < size; i++) {
692                  assertEquals(ints[i], q.take());              checkToArray(q);
693          } catch (InterruptedException e){              q.add(i);
694              unexpectedException();          }
695            // Provoke wraparound
696            int added = size * 2;
697            for (int i = 0; i < added; i++) {
698                checkToArray(q);
699                assertEquals((Integer) i, q.poll());
700                q.add(size + i);
701            }
702            for (int i = 0; i < size; i++) {
703                checkToArray(q);
704                assertEquals((Integer) (added + i), q.poll());
705          }          }
706      }      }
707    
708      /**      /**
709       * toArray(null) throws NPE       * toArray(incompatible array type) throws ArrayStoreException
710       */       */
711      public void testToArray_BadArg() {      public void testToArray_incompatibleArrayType() {
         try {  
712              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
713              Object o[] = q.toArray(null);          try {
714                q.toArray(new String[10]);
715              shouldThrow();              shouldThrow();
716          } catch(NullPointerException success){}          } catch (ArrayStoreException success) {}
     }  
   
     /**  
      * toArray with incompatable array type throws CCE  
      */  
     public void testToArray1_BadArg() {  
717          try {          try {
718              ArrayBlockingQueue q = populatedQueue(SIZE);              q.toArray(new String[0]);
             Object o[] = q.toArray(new String[10] );  
719              shouldThrow();              shouldThrow();
720          } catch(ArrayStoreException  success){}          } catch(ArrayStoreException  success){}
721      }      }
722    
   
723      /**      /**
724       * iterator iterates through all elements       * iterator iterates through all elements
725       */       */
726      public void testIterator() {      public void testIterator() throws InterruptedException {
727          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
728          Iterator it = q.iterator();          Iterator it = q.iterator();
729          try {          int i;
730              while(it.hasNext()){          for (i = 0; it.hasNext(); i++)
731                assertTrue(q.contains(it.next()));
732            assertEquals(i, SIZE);
733            assertIteratorExhausted(it);
734    
735            it = q.iterator();
736            for (i = 0; it.hasNext(); i++)
737                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
738            assertEquals(i, SIZE);
739            assertIteratorExhausted(it);
740              }              }
741          } catch (InterruptedException e){  
742              unexpectedException();      /**
743          }       * iterator of empty collection has no elements
744         */
745        public void testEmptyIterator() {
746            assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
747      }      }
748    
749      /**      /**
# Line 783  Line 760 
760          it.remove();          it.remove();
761    
762          it = q.iterator();          it = q.iterator();
763          assertEquals(it.next(), one);          assertSame(it.next(), one);
764          assertEquals(it.next(), three);          assertSame(it.next(), three);
765          assertFalse(it.hasNext());          assertFalse(it.hasNext());
766      }      }
767    
# Line 801  Line 778 
778    
779          int k = 0;          int k = 0;
780          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
781              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
782          }          }
783          assertEquals(3, k);          assertEquals(3, k);
784      }      }
# Line 815  Line 791 
791          q.add(one);          q.add(one);
792          q.add(two);          q.add(two);
793          q.add(three);          q.add(three);
         try {  
794              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
795                  q.remove();                  q.remove();
796                  it.next();                  it.next();
797              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
798          assertEquals(0, q.size());          assertEquals(0, q.size());
799      }      }
800    
   
801      /**      /**
802       * toString contains toStrings of elements       * toString contains toStrings of elements
803       */       */
# Line 835  Line 805 
805          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
806          String s = q.toString();          String s = q.toString();
807          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
808              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
809          }          }
810      }      }
811    
   
812      /**      /**
813       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
814       */       */
# Line 847  Line 816 
816          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
817          q.add(one);          q.add(one);
818          q.add(two);          q.add(two);
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                  threadAssertFalse(q.offer(three));              executor.execute(new CheckedRunnable() {
823                  try {                  public void realRun() throws InterruptedException {
824                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                      assertFalse(q.offer(three));
825                      threadAssertEquals(0, q.remainingCapacity());                      threadsStarted.await();
826                  }                      assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
827                  catch (InterruptedException e) {                      assertEquals(0, q.remainingCapacity());
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();
833                      Thread.sleep(SMALL_DELAY_MS);                      assertEquals(0, q.remainingCapacity());
834                      threadAssertEquals(one, q.take());                      assertSame(one, q.take());
835                  }                  }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
836              }              }
         });  
   
         joinPool(executor);  
   
837      }      }
838    
839      /**      /**
840       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
841       */       */
842      public void testPollInExecutor() {      public void testPollInExecutor() {
843          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
844          ExecutorService executor = Executors.newFixedThreadPool(2);          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
845          executor.execute(new Runnable() {          final ExecutorService executor = Executors.newFixedThreadPool(2);
846              public void run() {          try (PoolCleaner cleaner = cleaner(executor)) {
847                  threadAssertNull(q.poll());              executor.execute(new CheckedRunnable() {
848                  try {                  public void realRun() throws InterruptedException {
849                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                      assertNull(q.poll());
850                      threadAssertTrue(q.isEmpty());                      threadsStarted.await();
851                  }                      assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
852                  catch (InterruptedException e) {                      checkEmpty(q);
853                      threadUnexpectedException();                  }});
                 }  
             }  
         });  
854    
855          executor.execute(new Runnable() {              executor.execute(new CheckedRunnable() {
856              public void run() {                  public void realRun() throws InterruptedException {
857                  try {                      threadsStarted.await();
                     Thread.sleep(SMALL_DELAY_MS);  
858                      q.put(one);                      q.put(one);
859                    }});
860                  }                  }
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
   
         joinPool(executor);  
861      }      }
862    
863      /**      /**
864       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
865       */       */
866      public void testSerialization() {      public void testSerialization() throws Exception {
867          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
868            Queue y = serialClone(x);
869          try {  
870              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          assertNotSame(x, y);
871              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          assertEquals(x.size(), y.size());
872              out.writeObject(q);          assertEquals(x.toString(), y.toString());
873              out.close();          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
874            while (!x.isEmpty()) {
875              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              assertFalse(y.isEmpty());
876              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) {  
877          }          }
878            assertTrue(y.isEmpty());
879      }      }
880    
881      /**      /**
# Line 965  Line 885 
885          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
886          ArrayList l = new ArrayList();          ArrayList l = new ArrayList();
887          q.drainTo(l);          q.drainTo(l);
888          assertEquals(q.size(), 0);          assertEquals(0, q.size());
889          assertEquals(l.size(), SIZE);          assertEquals(SIZE, l.size());
890          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
891              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
892            q.add(zero);
893            q.add(one);
894            assertFalse(q.isEmpty());
895            assertTrue(q.contains(zero));
896            assertTrue(q.contains(one));
897            l.clear();
898            q.drainTo(l);
899            assertEquals(0, q.size());
900            assertEquals(2, l.size());
901            for (int i = 0; i < 2; ++i)
902                assertEquals(l.get(i), new Integer(i));
903      }      }
904    
905      /**      /**
906       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
907       */       */
908      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
909          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
910          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
911                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
912                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
913                      } catch (InterruptedException ie){              }});
914                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
915              t.start();              t.start();
916              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
917              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 919 
919              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
920                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
921              t.join();              t.join();
922              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
923      }      }
924    
925      /**      /**
926       * 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  
927       */       */
928      public void testDrainToN() {      public void testDrainToN() {
929            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE * 2);
930          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
931              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
932                    assertTrue(q.offer(new Integer(j)));
933              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
934              q.drainTo(l, i);              q.drainTo(l, i);
935              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
936              assertEquals(q.size(), SIZE-k);              assertEquals(k, l.size());
937              assertEquals(l.size(), k);              assertEquals(SIZE - k, q.size());
938              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
939                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
940                do {} while (q.poll() != null);
941          }          }
942      }      }
943    
944        /**
945         * remove(null), contains(null) always return false
946         */
947        public void testNeverContainsNull() {
948            Collection<?>[] qs = {
949                populatedQueue(0, 1, 10, false),
950                populatedQueue(2, 2, 10, true),
951            };
952    
953            for (Collection<?> q : qs) {
954                assertFalse(q.contains(null));
955                assertFalse(q.remove(null));
956            }
957        }
958  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8