[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.54, Tue Feb 21 02:04:17 2012 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 junit.framework.*;  import junit.framework.*;
10  import java.util.*;  import java.util.Arrays;
11  import java.util.concurrent.*;  import java.util.ArrayList;
12  import java.io.*;  import java.util.Collection;
13    import java.util.Iterator;
14    import java.util.NoSuchElementException;
15    import java.util.Queue;
16    import java.util.concurrent.ArrayBlockingQueue;
17    import java.util.concurrent.BlockingQueue;
18    import java.util.concurrent.CountDownLatch;
19    import java.util.concurrent.Executors;
20    import java.util.concurrent.ExecutorService;
21    import static java.util.concurrent.TimeUnit.MILLISECONDS;
22    
23  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
24    
25        public static class Fair extends BlockingQueueTest {
26            protected BlockingQueue emptyCollection() {
27                return new ArrayBlockingQueue(SIZE, true);
28            }
29        }
30    
31        public static class NonFair extends BlockingQueueTest {
32            protected BlockingQueue emptyCollection() {
33                return new ArrayBlockingQueue(SIZE, false);
34            }
35        }
36    
37      public static void main(String[] args) {      public static void main(String[] args) {
38          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
39      }      }
40    
41      public static Test suite() {      public static Test suite() {
42          return new TestSuite(ArrayBlockingQueueTest.class);          return newTestSuite(ArrayBlockingQueueTest.class,
43                                new Fair().testSuite(),
44                                new NonFair().testSuite());
45      }      }
46    
47      /**      /**
48       * Create a queue of given size containing consecutive       * Returns a new queue of given size containing consecutive
49       * Integers 0 ... n.       * Integers 0 ... n.
50       */       */
51      private ArrayBlockingQueue populatedQueue(int n) {      private ArrayBlockingQueue<Integer> populatedQueue(int n) {
52          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
53          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
54          for(int i = 0; i < n; i++)          for(int i = 0; i < n; i++)
55              assertTrue(q.offer(new Integer(i)));              assertTrue(q.offer(new Integer(i)));
# Line 46  Line 71 
71       */       */
72      public void testConstructor2() {      public void testConstructor2() {
73          try {          try {
74              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              new ArrayBlockingQueue(0);
75              shouldThrow();              shouldThrow();
76          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
77      }      }
78    
79      /**      /**
# Line 57  Line 81 
81       */       */
82      public void testConstructor3() {      public void testConstructor3() {
83          try {          try {
84              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              new ArrayBlockingQueue(1, true, null);
85              shouldThrow();              shouldThrow();
86          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
87      }      }
88    
89      /**      /**
90       * Initializing from Collection of null elements throws NPE       * Initializing from Collection of null elements throws NPE
91       */       */
92      public void testConstructor4() {      public void testConstructor4() {
93            Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
94          try {          try {
95              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE, false, elements);
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));  
96              shouldThrow();              shouldThrow();
97          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
98      }      }
99    
100      /**      /**
101       * Initializing from Collection with some null elements throws NPE       * Initializing from Collection with some null elements throws NPE
102       */       */
103      public void testConstructor5() {      public void testConstructor5() {
         try {  
104              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
105              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
106                  ints[i] = new Integer(i);              ints[i] = i;
107              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
108            try {
109                new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
110              shouldThrow();              shouldThrow();
111          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
112      }      }
113    
114      /**      /**
115       * Initializing from too large collection throws IAE       * Initializing from too large collection throws IAE
116       */       */
117      public void testConstructor6() {      public void testConstructor6() {
         try {  
118              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
119              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
120                  ints[i] = new Integer(i);              ints[i] = i;
121              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
122            try {
123                new ArrayBlockingQueue(SIZE - 1, false, elements);
124              shouldThrow();              shouldThrow();
125          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
126      }      }
127    
128      /**      /**
129       * Queue contains all elements of collection used to initialize       * Queue contains all elements of collection used to initialize
130       */       */
131      public void testConstructor7() {      public void testConstructor7() {
         try {  
132              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
133              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
134                  ints[i] = new Integer(i);              ints[i] = i;
135              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
136            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
137              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
138                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
139          }          }
         finally {}  
     }  
140    
141      /**      /**
142       * Queue transitions from empty to full when elements added       * Queue transitions from empty to full when elements added
# Line 151  Line 171 
171      }      }
172    
173      /**      /**
      *  offer(null) throws NPE  
      */  
     public void testOfferNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.offer(null);  
             shouldThrow();  
         } catch (NullPointerException success) { }  
     }  
   
     /**  
      *  add(null) throws NPE  
      */  
     public void testAddNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.add(null);  
             shouldThrow();  
         } catch (NullPointerException success) { }  
     }  
   
     /**  
174       * Offer succeeds if not full; fails if full       * Offer succeeds if not full; fails if full
175       */       */
176      public void testOffer() {      public void testOffer() {
# Line 192  Line 190 
190              }              }
191              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
192              q.add(new Integer(SIZE));              q.add(new Integer(SIZE));
         } catch (IllegalStateException success){  
         }  
     }  
   
     /**  
      *  addAll(null) throws NPE  
      */  
     public void testAddAll1() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.addAll(null);  
193              shouldThrow();              shouldThrow();
194          }          } catch (IllegalStateException success) {}
         catch (NullPointerException success) {}  
195      }      }
196    
197      /**      /**
# Line 216  Line 202 
202              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
203              q.addAll(q);              q.addAll(q);
204              shouldThrow();              shouldThrow();
205            } catch (IllegalArgumentException success) {}
206          }          }
         catch (IllegalArgumentException success) {}  
     }  
   
207    
208      /**      /**
      *  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) {}  
     }  
     /**  
209       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
210       * possibly adding some elements       * possibly adding some elements
211       */       */
# Line 245  Line 217 
217                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
218              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
219              shouldThrow();              shouldThrow();
220            } catch (NullPointerException success) {}
221          }          }
222          catch (NullPointerException success) {}  
     }  
223      /**      /**
224       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
225       */       */
# Line 259  Line 231 
231                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
232              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
233              shouldThrow();              shouldThrow();
234            } catch (IllegalStateException success) {}
235          }          }
236          catch (IllegalStateException success) {}  
     }  
237      /**      /**
238       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
239       */       */
240      public void testAddAll5() {      public void testAddAll5() {
         try {  
241              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
242              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
243              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 277  Line 248 
248              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
249                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
250          }          }
         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();  
         }  
      }  
251    
252      /**      /**
253       * all elements successfully put are contained       * all elements successfully put are contained
254       */       */
255       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
256               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
257               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
258                   Integer I = new Integer(i);                   Integer I = new Integer(i);
# Line 309  Line 261 
261               }               }
262               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
263           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
264    
265      /**      /**
266       * put blocks interruptibly if full       * put blocks interruptibly if full
267       */       */
268      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
269          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
270                  public void run() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
271                      int added = 0;          Thread t = newStartedThread(new CheckedRunnable() {
272                public void realRun() throws InterruptedException {
273                    for (int i = 0; i < SIZE; ++i)
274                        q.put(i);
275                    assertEquals(SIZE, q.size());
276                    assertEquals(0, q.remainingCapacity());
277    
278                    Thread.currentThread().interrupt();
279                      try {                      try {
280                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                      q.put(99);
281                          for (int i = 0; i < SIZE; ++i) {                      shouldThrow();
282                              q.put(new Integer(i));                  } catch (InterruptedException success) {}
283                              ++added;                  assertFalse(Thread.interrupted());
284                          }  
285                          q.put(new Integer(SIZE));                  pleaseInterrupt.countDown();
                         threadShouldThrow();  
                     } catch (InterruptedException ie){  
                         threadAssertEquals(added, SIZE);  
                     }  
                 }});  
286          try {          try {
287              t.start();                      q.put(99);
288             Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
289                    } catch (InterruptedException success) {}
290                    assertFalse(Thread.interrupted());
291                }});
292    
293            await(pleaseInterrupt);
294            assertThreadStaysAlive(t);
295             t.interrupt();             t.interrupt();
296             t.join();          awaitTermination(t);
297          }          assertEquals(SIZE, q.size());
298          catch (InterruptedException ie) {          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
299      }      }
300    
301      /**      /**
302       * put blocks waiting for take when full       * put blocks interruptibly waiting for take when full
303       */       */
304      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
305          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
306          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
307                  public void run() {          final CountDownLatch pleaseTake = new CountDownLatch(1);
308                      int added = 0;          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
309                      try {          Thread t = newStartedThread(new CheckedRunnable() {
310                          q.put(new Object());              public void realRun() throws InterruptedException {
311                          ++added;                  for (int i = 0; i < capacity; i++)
312                          q.put(new Object());                      q.put(i);
313                          ++added;                  pleaseTake.countDown();
314                          q.put(new Object());                  q.put(86);
315                          ++added;  
316                          q.put(new Object());                  pleaseInterrupt.countDown();
                         ++added;  
                         threadShouldThrow();  
                     } catch (InterruptedException e){  
                         threadAssertTrue(added >= 2);  
                     }  
                 }  
             });  
317          try {          try {
318              t.start();                      q.put(99);
319              Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
320              q.take();                  } catch (InterruptedException success) {}
321                    assertFalse(Thread.interrupted());
322                }});
323    
324            await(pleaseTake);
325            assertEquals(0, q.remainingCapacity());
326            assertEquals(0, q.take());
327    
328            await(pleaseInterrupt);
329            assertThreadStaysAlive(t);
330              t.interrupt();              t.interrupt();
331              t.join();          awaitTermination(t);
332          } catch (Exception e){          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
333      }      }
334    
335      /**      /**
336       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
337       */       */
338      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
339          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
340          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
341                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
342                      try {              public void realRun() throws InterruptedException {
343                          q.put(new Object());                          q.put(new Object());
344                          q.put(new Object());                          q.put(new Object());
345                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  long startTime = System.nanoTime();
346                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
347                          threadShouldThrow();                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
348                    pleaseInterrupt.countDown();
349                    try {
350                        q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
351                        shouldThrow();
352                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
353                  }              }});
             });  
354    
355          try {          await(pleaseInterrupt);
356              t.start();          assertThreadStaysAlive(t);
             Thread.sleep(SHORT_DELAY_MS);  
357              t.interrupt();              t.interrupt();
358              t.join();          awaitTermination(t);
         } catch (Exception e){  
             unexpectedException();  
         }  
359      }      }
360    
361      /**      /**
362       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
363       */       */
364      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
365              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
366              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
367                  assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
368          }          }
369      }      }
370    
371      /**      /**
372       * take blocks interruptibly when empty       * Take removes existing elements until empty, then blocks interruptibly
373       */       */
374      public void testTakeFromEmpty() {      public void testBlockingTake() throws InterruptedException {
375          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = populatedQueue(SIZE);
376          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
377                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
378                public void realRun() throws InterruptedException {
379                    for (int i = 0; i < SIZE; ++i) {
380                        assertEquals(i, q.take());
381                    }
382    
383                    Thread.currentThread().interrupt();
384                      try {                      try {
385                          q.take();                          q.take();
386                          threadShouldThrow();                      shouldThrow();
387                      } catch (InterruptedException success){ }                      } catch (InterruptedException success){ }
388                  }                  assertFalse(Thread.interrupted());
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         } catch (Exception e){  
             unexpectedException();  
         }  
     }  
389    
390      /**                  pleaseInterrupt.countDown();
      * Take removes existing elements until empty, then blocks interruptibly  
      */  
     public void testBlockingTake() {  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
391                      try {                      try {
                         ArrayBlockingQueue q = populatedQueue(SIZE);  
                         for (int i = 0; i < SIZE; ++i) {  
                             threadAssertEquals(i, ((Integer)q.take()).intValue());  
                         }  
392                          q.take();                          q.take();
393                          threadShouldThrow();                      shouldThrow();
394                      } catch (InterruptedException success){                  } catch (InterruptedException success) {}
395                      }                  assertFalse(Thread.interrupted());
396                  }});                  }});
397          try {  
398              t.start();          await(pleaseInterrupt);
399              Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
400              t.interrupt();              t.interrupt();
401              t.join();          awaitTermination(t);
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
402      }      }
403    
   
404      /**      /**
405       * poll succeeds unless empty       * poll succeeds unless empty
406       */       */
407      public void testPoll() {      public void testPoll() {
408          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
409          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
410              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
411          }          }
412          assertNull(q.poll());          assertNull(q.poll());
413      }      }
414    
415      /**      /**
416       * timed pool with zero timeout succeeds when non-empty, else times out       * timed poll with zero timeout succeeds when non-empty, else times out
417       */       */
418      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
419              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
420              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
421                  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();  
422          }          }
423            assertNull(q.poll(0, MILLISECONDS));
424            checkEmpty(q);
425      }      }
426    
427      /**      /**
428       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed poll with nonzero timeout succeeds when non-empty, else times out
429       */       */
430      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
431              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
432              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
433                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());              long startTime = System.nanoTime();
434              }              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
435              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
         } catch (InterruptedException e){  
             unexpectedException();  
436          }          }
437            long startTime = System.nanoTime();
438            assertNull(q.poll(timeoutMillis(), MILLISECONDS));
439            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
440            checkEmpty(q);
441      }      }
442    
443      /**      /**
444       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
445       * returning timeout status       * returning timeout status
446       */       */
447      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
448          Thread t = new Thread(new Runnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
449                  public void run() {          final CountDownLatch aboutToWait = new CountDownLatch(1);
450                      try {          Thread t = newStartedThread(new CheckedRunnable() {
451                          ArrayBlockingQueue q = populatedQueue(SIZE);              public void realRun() throws InterruptedException {
452                          for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
453                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      long t0 = System.nanoTime();
454                        assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
455                        assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
456                          }                          }
457                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                  long t0 = System.nanoTime();
458                    aboutToWait.countDown();
459                    try {
460                        q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
461                        shouldThrow();
462                      } catch (InterruptedException success){                      } catch (InterruptedException success){
463                        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
464                      }                      }
465                  }});                  }});
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
466    
467      /**          aboutToWait.await();
468       *  timed poll before a delayed offer fails; after offer succeeds;          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
      *  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));  
469              t.interrupt();              t.interrupt();
470              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
471          } catch (Exception e){          checkEmpty(q);
             unexpectedException();  
         }  
472      }      }
473    
   
474      /**      /**
475       * peek returns next element, or null if empty       * peek returns next element, or null if empty
476       */       */
477      public void testPeek() {      public void testPeek() {
478          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
479          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
480              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
481              q.poll();              assertEquals(i, q.poll());
482              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
483                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
484          }          }
485          assertNull(q.peek());          assertNull(q.peek());
486      }      }
# Line 586  Line 491 
491      public void testElement() {      public void testElement() {
492          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
493          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
494              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
495              q.poll();              assertEquals(i, q.poll());
496          }          }
497          try {          try {
498              q.element();              q.element();
499              shouldThrow();              shouldThrow();
500          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
501      }      }
502    
503      /**      /**
# Line 602  Line 506 
506      public void testRemove() {      public void testRemove() {
507          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
508          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
509              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
510          }          }
511          try {          try {
512              q.remove();              q.remove();
513              shouldThrow();              shouldThrow();
514          } 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());  
515      }      }
516    
517      /**      /**
# Line 633  Line 521 
521          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
522          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
523              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
524              q.poll();              assertEquals(i, q.poll());
525              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
526          }          }
527      }      }
# Line 649  Line 537 
537          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
538          q.add(one);          q.add(one);
539          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
540            assertTrue(q.contains(one));
541          q.clear();          q.clear();
542          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
543      }      }
# Line 703  Line 592 
592      }      }
593    
594      /**      /**
595       *  toArray contains all elements       * toArray contains all elements in FIFO order
596       */       */
597      public void testToArray() {      public void testToArray() {
598          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
599          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
600          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
601              assertEquals(o[i], q.take());              assertSame(o[i], q.poll());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
602      }      }
603    
604      /**      /**
605       * toArray(a) contains all elements       * toArray(a) contains all elements in FIFO order
606       */       */
607      public void testToArray2() {      public void testToArray2() {
608          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue<Integer> q = populatedQueue(SIZE);
609          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
610          ints = (Integer[])q.toArray(ints);          Integer[] array = q.toArray(ints);
611          try {          assertSame(ints, array);
612              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
613                  assertEquals(ints[i], q.take());              assertSame(ints[i], q.poll());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
614      }      }
615    
616      /**      /**
617       * toArray(null) throws NPE       * toArray(incompatible array type) throws ArrayStoreException
      */  
     public void testToArray_BadArg() {  
         try {  
             ArrayBlockingQueue q = populatedQueue(SIZE);  
             Object o[] = q.toArray(null);  
             shouldThrow();  
         } catch(NullPointerException success){}  
     }  
   
     /**  
      * toArray with incompatable array type throws CCE  
618       */       */
619      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
620              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
621              Object o[] = q.toArray(new String[10] );          try {
622                q.toArray(new String[10]);
623              shouldThrow();              shouldThrow();
624          } catch(ArrayStoreException  success){}          } catch(ArrayStoreException  success){}
625      }      }
626    
   
627      /**      /**
628       * iterator iterates through all elements       * iterator iterates through all elements
629       */       */
630      public void testIterator() {      public void testIterator() throws InterruptedException {
631          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
632          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
633              while(it.hasNext()){              while(it.hasNext()){
634                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
635              }              }
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
636      }      }
637    
638      /**      /**
# Line 783  Line 649 
649          it.remove();          it.remove();
650    
651          it = q.iterator();          it = q.iterator();
652          assertEquals(it.next(), one);          assertSame(it.next(), one);
653          assertEquals(it.next(), three);          assertSame(it.next(), three);
654          assertFalse(it.hasNext());          assertFalse(it.hasNext());
655      }      }
656    
# Line 801  Line 667 
667    
668          int k = 0;          int k = 0;
669          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
670              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
671          }          }
672          assertEquals(3, k);          assertEquals(3, k);
673      }      }
# Line 815  Line 680 
680          q.add(one);          q.add(one);
681          q.add(two);          q.add(two);
682          q.add(three);          q.add(three);
         try {  
683              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
684                  q.remove();                  q.remove();
685                  it.next();                  it.next();
686              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
687          assertEquals(0, q.size());          assertEquals(0, q.size());
688      }      }
689    
   
690      /**      /**
691       * toString contains toStrings of elements       * toString contains toStrings of elements
692       */       */
# Line 835  Line 694 
694          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
695          String s = q.toString();          String s = q.toString();
696          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
697              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
698          }          }
699      }      }
700    
   
701      /**      /**
702       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
703       */       */
# Line 848  Line 706 
706          q.add(one);          q.add(one);
707          q.add(two);          q.add(two);
708          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
709          executor.execute(new Runnable() {          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
710              public void run() {          executor.execute(new CheckedRunnable() {
711                  threadAssertFalse(q.offer(three));              public void realRun() throws InterruptedException {
712                  try {                  assertFalse(q.offer(three));
713                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  threadsStarted.await();
714                      threadAssertEquals(0, q.remainingCapacity());                  assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
715                  }                  assertEquals(0, q.remainingCapacity());
716                  catch (InterruptedException e) {              }});
                     threadUnexpectedException();  
                 }  
             }  
         });  
717    
718          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
719              public void run() {              public void realRun() throws InterruptedException {
720                  try {                  threadsStarted.await();
721                      Thread.sleep(SMALL_DELAY_MS);                  assertEquals(0, q.remainingCapacity());
722                      threadAssertEquals(one, q.take());                  assertSame(one, q.take());
723                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
724    
725          joinPool(executor);          joinPool(executor);
   
726      }      }
727    
728      /**      /**
729       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
730       */       */
731      public void testPollInExecutor() {      public void testPollInExecutor() {
732          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
733            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
734          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
735          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
736              public void run() {              public void realRun() throws InterruptedException {
737                  threadAssertNull(q.poll());                  assertNull(q.poll());
738                  try {                  threadsStarted.await();
739                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
740                      threadAssertTrue(q.isEmpty());                  checkEmpty(q);
741                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
742    
743          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
744              public void run() {              public void realRun() throws InterruptedException {
745                  try {                  threadsStarted.await();
                     Thread.sleep(SMALL_DELAY_MS);  
746                      q.put(one);                      q.put(one);
747                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
748    
749          joinPool(executor);          joinPool(executor);
750      }      }
# Line 914  Line 752 
752      /**      /**
753       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
754       */       */
755      public void testSerialization() {      public void testSerialization() throws Exception {
756          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
757            Queue y = serialClone(x);
758          try {  
759              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          assertTrue(x != y);
760              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          assertEquals(x.size(), y.size());
761              out.writeObject(q);          assertEquals(x.toString(), y.toString());
762              out.close();          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
763            while (!x.isEmpty()) {
764              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              assertFalse(y.isEmpty());
765              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) {  
766          }          }
767            assertTrue(y.isEmpty());
768      }      }
769    
770      /**      /**
# Line 965  Line 774 
774          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
775          ArrayList l = new ArrayList();          ArrayList l = new ArrayList();
776          q.drainTo(l);          q.drainTo(l);
777          assertEquals(q.size(), 0);          assertEquals(0, q.size());
778          assertEquals(l.size(), SIZE);          assertEquals(SIZE, l.size());
779          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
780              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
781            q.add(zero);
782            q.add(one);
783            assertFalse(q.isEmpty());
784            assertTrue(q.contains(zero));
785            assertTrue(q.contains(one));
786            l.clear();
787            q.drainTo(l);
788            assertEquals(0, q.size());
789            assertEquals(2, l.size());
790            for (int i = 0; i < 2; ++i)
791                assertEquals(l.get(i), new Integer(i));
792      }      }
793    
794      /**      /**
795       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
796       */       */
797      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
798          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
799          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
800                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
801                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
802                      } catch (InterruptedException ie){              }});
803                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
804              t.start();              t.start();
805              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
806              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 808 
808              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
809                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
810              t.join();              t.join();
811              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
812      }      }
813    
814      /**      /**
815       * 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  
816       */       */
817      public void testDrainToN() {      public void testDrainToN() {
818            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
819          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
820              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
821                    assertTrue(q.offer(new Integer(j)));
822              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
823              q.drainTo(l, i);              q.drainTo(l, i);
824              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
825              assertEquals(q.size(), SIZE-k);              assertEquals(k, l.size());
826              assertEquals(l.size(), k);              assertEquals(SIZE-k, q.size());
827              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
828                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
829                while (q.poll() != null) ;
830          }          }
831      }      }
832    
   
833  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8