[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.47, Fri May 27 20:07:24 2011 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.*;
11  import java.util.concurrent.*;  import java.util.concurrent.*;
12    import static java.util.concurrent.TimeUnit.MILLISECONDS;
13  import java.io.*;  import java.io.*;
14    
15  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
16    
17        public static class Fair extends BlockingQueueTest {
18            protected BlockingQueue emptyCollection() {
19                return new ArrayBlockingQueue(20, true);
20            }
21        }
22    
23        public static class NonFair extends BlockingQueueTest {
24            protected BlockingQueue emptyCollection() {
25                return new ArrayBlockingQueue(20, false);
26            }
27        }
28    
29      public static void main(String[] args) {      public static void main(String[] args) {
30          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
31      }      }
32    
33      public static Test suite() {      public static Test suite() {
34          return new TestSuite(ArrayBlockingQueueTest.class);          return newTestSuite(ArrayBlockingQueueTest.class,
35                                new Fair().testSuite(),
36                                new NonFair().testSuite());
37      }      }
38    
39      /**      /**
40       * Create a queue of given size containing consecutive       * Create a queue of given size containing consecutive
41       * Integers 0 ... n.       * Integers 0 ... n.
42       */       */
43      private ArrayBlockingQueue populatedQueue(int n) {      private ArrayBlockingQueue<Integer> populatedQueue(int n) {
44          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
45          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
46          for(int i = 0; i < n; i++)          for(int i = 0; i < n; i++)
47              assertTrue(q.offer(new Integer(i)));              assertTrue(q.offer(new Integer(i)));
# Line 48  Line 65 
65          try {          try {
66              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              ArrayBlockingQueue q = new ArrayBlockingQueue(0);
67              shouldThrow();              shouldThrow();
68          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
69      }      }
70    
71      /**      /**
# Line 59  Line 75 
75          try {          try {
76              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
77              shouldThrow();              shouldThrow();
78          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
79      }      }
80    
81      /**      /**
# Line 71  Line 86 
86              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
87              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
88              shouldThrow();              shouldThrow();
89          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
90      }      }
91    
92      /**      /**
# Line 85  Line 99 
99                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
100              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
101              shouldThrow();              shouldThrow();
102          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
103      }      }
104    
105      /**      /**
# Line 99  Line 112 
112                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
113              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
114              shouldThrow();              shouldThrow();
115          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
116      }      }
117    
118      /**      /**
119       * Queue contains all elements of collection used to initialize       * Queue contains all elements of collection used to initialize
120       */       */
121      public void testConstructor7() {      public void testConstructor7() {
         try {  
122              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
123              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
124                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
# Line 115  Line 126 
126              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
127                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
128          }          }
         finally {}  
     }  
129    
130      /**      /**
131       * Queue transitions from empty to full when elements added       * Queue transitions from empty to full when elements added
# Line 192  Line 201 
201              }              }
202              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
203              q.add(new Integer(SIZE));              q.add(new Integer(SIZE));
204          } catch (IllegalStateException success){              shouldThrow();
205          }          } catch (IllegalStateException success) {}
206      }      }
207    
208      /**      /**
# Line 204  Line 213 
213              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
214              q.addAll(null);              q.addAll(null);
215              shouldThrow();              shouldThrow();
216          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
217      }      }
218    
219      /**      /**
# Line 216  Line 224 
224              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
225              q.addAll(q);              q.addAll(q);
226              shouldThrow();              shouldThrow();
227            } catch (IllegalArgumentException success) {}
228          }          }
         catch (IllegalArgumentException success) {}  
     }  
   
229    
230      /**      /**
231       *  addAll of a collection with null elements throws NPE       *  addAll of a collection with null elements throws NPE
# Line 230  Line 236 
236              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
237              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
238              shouldThrow();              shouldThrow();
239            } catch (NullPointerException success) {}
240          }          }
241          catch (NullPointerException success) {}  
     }  
242      /**      /**
243       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
244       * possibly adding some elements       * possibly adding some elements
# Line 245  Line 251 
251                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
252              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
253              shouldThrow();              shouldThrow();
254            } catch (NullPointerException success) {}
255          }          }
256          catch (NullPointerException success) {}  
     }  
257      /**      /**
258       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
259       */       */
# Line 259  Line 265 
265                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
266              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
267              shouldThrow();              shouldThrow();
268            } catch (IllegalStateException success) {}
269          }          }
270          catch (IllegalStateException success) {}  
     }  
271      /**      /**
272       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
273       */       */
274      public void testAddAll5() {      public void testAddAll5() {
         try {  
275              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
276              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
277              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 277  Line 282 
282              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
283                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
284          }          }
         finally {}  
     }  
285    
286      /**      /**
287       *  put(null) throws NPE       *  put(null) throws NPE
288       */       */
289       public void testPutNull() {      public void testPutNull() throws InterruptedException {
290          try {          try {
291              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
292              q.put(null);              q.put(null);
293              shouldThrow();              shouldThrow();
294          }          } catch (NullPointerException success) {}
         catch (NullPointerException success){  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
295       }       }
296    
297      /**      /**
298       * all elements successfully put are contained       * all elements successfully put are contained
299       */       */
300       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
301               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
302               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
303                   Integer I = new Integer(i);                   Integer I = new Integer(i);
# Line 309  Line 306 
306               }               }
307               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
308           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
309    
310      /**      /**
311       * put blocks interruptibly if full       * put blocks interruptibly if full
312       */       */
313      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
314          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
315                  public void run() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
316                      int added = 0;          Thread t = newStartedThread(new CheckedRunnable() {
317                public void realRun() throws InterruptedException {
318                    for (int i = 0; i < SIZE; ++i)
319                        q.put(i);
320                    assertEquals(SIZE, q.size());
321                    assertEquals(0, q.remainingCapacity());
322    
323                    Thread.currentThread().interrupt();
324                      try {                      try {
325                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                      q.put(99);
326                          for (int i = 0; i < SIZE; ++i) {                      shouldThrow();
327                              q.put(new Integer(i));                  } catch (InterruptedException success) {}
328                              ++added;                  assertFalse(Thread.interrupted());
329                          }  
330                          q.put(new Integer(SIZE));                  pleaseInterrupt.countDown();
                         threadShouldThrow();  
                     } catch (InterruptedException ie){  
                         threadAssertEquals(added, SIZE);  
                     }  
                 }});  
331          try {          try {
332              t.start();                      q.put(99);
333             Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
334                    } catch (InterruptedException success) {}
335                    assertFalse(Thread.interrupted());
336                }});
337    
338            await(pleaseInterrupt);
339            assertThreadStaysAlive(t);
340             t.interrupt();             t.interrupt();
341             t.join();          awaitTermination(t);
342          }          assertEquals(SIZE, q.size());
343          catch (InterruptedException ie) {          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
344      }      }
345    
346      /**      /**
347       * put blocks waiting for take when full       * put blocks interruptibly waiting for take when full
348       */       */
349      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
350          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
351          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
352                  public void run() {          final CountDownLatch pleaseTake = new CountDownLatch(1);
353                      int added = 0;          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
354                      try {          Thread t = newStartedThread(new CheckedRunnable() {
355                          q.put(new Object());              public void realRun() throws InterruptedException {
356                          ++added;                  for (int i = 0; i < capacity; i++)
357                          q.put(new Object());                      q.put(i);
358                          ++added;                  pleaseTake.countDown();
359                          q.put(new Object());                  q.put(86);
360                          ++added;  
361                          q.put(new Object());                  pleaseInterrupt.countDown();
                         ++added;  
                         threadShouldThrow();  
                     } catch (InterruptedException e){  
                         threadAssertTrue(added >= 2);  
                     }  
                 }  
             });  
362          try {          try {
363              t.start();                      q.put(99);
364              Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
365              q.take();                  } catch (InterruptedException success) {}
366                    assertFalse(Thread.interrupted());
367                }});
368    
369            await(pleaseTake);
370            assertEquals(q.remainingCapacity(), 0);
371            assertEquals(0, q.take());
372    
373            await(pleaseInterrupt);
374            assertThreadStaysAlive(t);
375              t.interrupt();              t.interrupt();
376              t.join();          awaitTermination(t);
377          } catch (Exception e){          assertEquals(q.remainingCapacity(), 0);
             unexpectedException();  
         }  
378      }      }
379    
380      /**      /**
381       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
382       */       */
383      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
384          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
385          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
386                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
387                      try {              public void realRun() throws InterruptedException {
388                          q.put(new Object());                          q.put(new Object());
389                          q.put(new Object());                          q.put(new Object());
390                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  long startTime = System.nanoTime();
391                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
392                          threadShouldThrow();                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
393                    pleaseInterrupt.countDown();
394                    try {
395                        q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
396                        shouldThrow();
397                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
398                  }              }});
             });  
399    
400          try {          await(pleaseInterrupt);
401              t.start();          assertThreadStaysAlive(t);
             Thread.sleep(SHORT_DELAY_MS);  
402              t.interrupt();              t.interrupt();
403              t.join();          awaitTermination(t);
         } catch (Exception e){  
             unexpectedException();  
         }  
404      }      }
405    
406      /**      /**
407       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
408       */       */
409      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
410              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
411              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
412                  assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
413          }          }
414      }      }
415    
416      /**      /**
417       * take blocks interruptibly when empty       * Take removes existing elements until empty, then blocks interruptibly
418       */       */
419      public void testTakeFromEmpty() {      public void testBlockingTake() throws InterruptedException {
420          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = populatedQueue(SIZE);
421          Thread t = new Thread(new Runnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
422                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
423                public void realRun() throws InterruptedException {
424                    for (int i = 0; i < SIZE; ++i) {
425                        assertEquals(i, q.take());
426                    }
427    
428                    Thread.currentThread().interrupt();
429                      try {                      try {
430                          q.take();                          q.take();
431                          threadShouldThrow();                      shouldThrow();
432                      } catch (InterruptedException success){ }                      } catch (InterruptedException success){ }
433                  }                  assertFalse(Thread.interrupted());
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         } catch (Exception e){  
             unexpectedException();  
         }  
     }  
434    
435      /**                  pleaseInterrupt.countDown();
      * Take removes existing elements until empty, then blocks interruptibly  
      */  
     public void testBlockingTake() {  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
436                      try {                      try {
                         ArrayBlockingQueue q = populatedQueue(SIZE);  
                         for (int i = 0; i < SIZE; ++i) {  
                             threadAssertEquals(i, ((Integer)q.take()).intValue());  
                         }  
437                          q.take();                          q.take();
438                          threadShouldThrow();                      shouldThrow();
439                      } catch (InterruptedException success){                  } catch (InterruptedException success) {}
440                      }                  assertFalse(Thread.interrupted());
441                  }});                  }});
442          try {  
443              t.start();          await(pleaseInterrupt);
444              Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
445              t.interrupt();              t.interrupt();
446              t.join();          awaitTermination(t);
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
447          }          }
     }  
   
448    
449      /**      /**
450       * poll succeeds unless empty       * poll succeeds unless empty
# Line 476  Line 452 
452      public void testPoll() {      public void testPoll() {
453          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
454          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
455              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
456          }          }
457          assertNull(q.poll());          assertNull(q.poll());
458      }      }
459    
460      /**      /**
461       * timed pool with zero timeout succeeds when non-empty, else times out       * timed poll with zero timeout succeeds when non-empty, else times out
462       */       */
463      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
464              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
465              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
466                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());              assertEquals(i, q.poll(0, MILLISECONDS));
             }  
             assertNull(q.poll(0, TimeUnit.MILLISECONDS));  
         } catch (InterruptedException e){  
             unexpectedException();  
467          }          }
468            assertNull(q.poll(0, MILLISECONDS));
469            checkEmpty(q);
470      }      }
471    
472      /**      /**
473       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed poll with nonzero timeout succeeds when non-empty, else times out
474       */       */
475      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
476              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
477              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
478                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());              long startTime = System.nanoTime();
479              }              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
480              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
         } catch (InterruptedException e){  
             unexpectedException();  
481          }          }
482            long startTime = System.nanoTime();
483            assertNull(q.poll(timeoutMillis(), MILLISECONDS));
484            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
485            checkEmpty(q);
486      }      }
487    
488      /**      /**
489       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
490       * returning timeout status       * returning timeout status
491       */       */
492      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
493          Thread t = new Thread(new Runnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
494                  public void run() {          final CountDownLatch aboutToWait = new CountDownLatch(1);
495                      try {          Thread t = newStartedThread(new CheckedRunnable() {
496                          ArrayBlockingQueue q = populatedQueue(SIZE);              public void realRun() throws InterruptedException {
497                          for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
498                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      long t0 = System.nanoTime();
499                        assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
500                        assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
501                          }                          }
502                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                  long t0 = System.nanoTime();
503                    aboutToWait.countDown();
504                    try {
505                        q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
506                        shouldThrow();
507                      } catch (InterruptedException success){                      } catch (InterruptedException success){
508                        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
509                      }                      }
510                  }});                  }});
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
511    
512      /**          aboutToWait.await();
513       *  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));  
514              t.interrupt();              t.interrupt();
515              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
516          } catch (Exception e){          checkEmpty(q);
             unexpectedException();  
517          }          }
     }  
   
518    
519      /**      /**
520       * peek returns next element, or null if empty       * peek returns next element, or null if empty
# Line 572  Line 522 
522      public void testPeek() {      public void testPeek() {
523          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
524          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
525              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
526              q.poll();              assertEquals(i, q.poll());
527              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
528                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
529          }          }
530          assertNull(q.peek());          assertNull(q.peek());
531      }      }
# Line 586  Line 536 
536      public void testElement() {      public void testElement() {
537          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
538          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
539              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
540              q.poll();              assertEquals(i, q.poll());
541          }          }
542          try {          try {
543              q.element();              q.element();
544              shouldThrow();              shouldThrow();
545          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
546      }      }
547    
548      /**      /**
# Line 602  Line 551 
551      public void testRemove() {      public void testRemove() {
552          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
553          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
554              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
555          }          }
556          try {          try {
557              q.remove();              q.remove();
558              shouldThrow();              shouldThrow();
559          } catch (NoSuchElementException success){          } catch (NoSuchElementException success) {}
         }  
560      }      }
561    
562      /**      /**
# Line 633  Line 581 
581          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
582          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
583              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
584              q.poll();              assertEquals(i, q.poll());
585              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
586          }          }
587      }      }
# Line 649  Line 597 
597          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
598          q.add(one);          q.add(one);
599          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
600            assertTrue(q.contains(one));
601          q.clear();          q.clear();
602          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
603      }      }
# Line 703  Line 652 
652      }      }
653    
654      /**      /**
655       *  toArray contains all elements       * toArray contains all elements in FIFO order
656       */       */
657      public void testToArray() {      public void testToArray() {
658          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
659          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
660          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
661              assertEquals(o[i], q.take());              assertSame(o[i], q.poll());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
662      }      }
663    
664      /**      /**
665       * toArray(a) contains all elements       * toArray(a) contains all elements in FIFO order
666       */       */
667      public void testToArray2() {      public void testToArray2() {
668          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue<Integer> q = populatedQueue(SIZE);
669          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
670          ints = (Integer[])q.toArray(ints);          Integer[] array = q.toArray(ints);
671          try {          assertSame(ints, array);
672              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
673                  assertEquals(ints[i], q.take());              assertSame(ints[i], q.poll());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
674      }      }
675    
676      /**      /**
677       * toArray(null) throws NPE       * toArray(null) throws NullPointerException
678       */       */
679      public void testToArray_BadArg() {      public void testToArray_NullArg() {
         try {  
680              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
681              Object o[] = q.toArray(null);          try {
682                q.toArray(null);
683              shouldThrow();              shouldThrow();
684          } catch(NullPointerException success){}          } catch(NullPointerException success){}
685      }      }
686    
687      /**      /**
688       * toArray with incompatable array type throws CCE       * toArray(incompatible array type) throws ArrayStoreException
689       */       */
690      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
691              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
692              Object o[] = q.toArray(new String[10] );          try {
693                q.toArray(new String[10]);
694              shouldThrow();              shouldThrow();
695          } catch(ArrayStoreException  success){}          } catch(ArrayStoreException  success){}
696      }      }
697    
   
698      /**      /**
699       * iterator iterates through all elements       * iterator iterates through all elements
700       */       */
701      public void testIterator() {      public void testIterator() throws InterruptedException {
702          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
703          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
704              while(it.hasNext()){              while(it.hasNext()){
705                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
706              }              }
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
707      }      }
708    
709      /**      /**
# Line 783  Line 720 
720          it.remove();          it.remove();
721    
722          it = q.iterator();          it = q.iterator();
723          assertEquals(it.next(), one);          assertSame(it.next(), one);
724          assertEquals(it.next(), three);          assertSame(it.next(), three);
725          assertFalse(it.hasNext());          assertFalse(it.hasNext());
726      }      }
727    
# Line 801  Line 738 
738    
739          int k = 0;          int k = 0;
740          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
741              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
742          }          }
743          assertEquals(3, k);          assertEquals(3, k);
744      }      }
# Line 815  Line 751 
751          q.add(one);          q.add(one);
752          q.add(two);          q.add(two);
753          q.add(three);          q.add(three);
         try {  
754              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
755                  q.remove();                  q.remove();
756                  it.next();                  it.next();
757              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
758          assertEquals(0, q.size());          assertEquals(0, q.size());
759      }      }
760    
   
761      /**      /**
762       * toString contains toStrings of elements       * toString contains toStrings of elements
763       */       */
# Line 835  Line 765 
765          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
766          String s = q.toString();          String s = q.toString();
767          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
768              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
769          }          }
770      }      }
771    
   
772      /**      /**
773       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
774       */       */
# Line 848  Line 777 
777          q.add(one);          q.add(one);
778          q.add(two);          q.add(two);
779          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
780          executor.execute(new Runnable() {          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
781              public void run() {          executor.execute(new CheckedRunnable() {
782                  threadAssertFalse(q.offer(three));              public void realRun() throws InterruptedException {
783                  try {                  assertFalse(q.offer(three));
784                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  threadsStarted.await();
785                      threadAssertEquals(0, q.remainingCapacity());                  assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
786                  }                  assertEquals(0, q.remainingCapacity());
787                  catch (InterruptedException e) {              }});
                     threadUnexpectedException();  
                 }  
             }  
         });  
788    
789          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
790              public void run() {              public void realRun() throws InterruptedException {
791                  try {                  threadsStarted.await();
792                      Thread.sleep(SMALL_DELAY_MS);                  assertEquals(0, q.remainingCapacity());
793                      threadAssertEquals(one, q.take());                  assertSame(one, q.take());
794                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
795    
796          joinPool(executor);          joinPool(executor);
   
797      }      }
798    
799      /**      /**
800       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
801       */       */
802      public void testPollInExecutor() {      public void testPollInExecutor() {
803          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
804            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
805          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
806          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
807              public void run() {              public void realRun() throws InterruptedException {
808                  threadAssertNull(q.poll());                  assertNull(q.poll());
809                  try {                  threadsStarted.await();
810                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
811                      threadAssertTrue(q.isEmpty());                  checkEmpty(q);
812                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
813    
814          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
815              public void run() {              public void realRun() throws InterruptedException {
816                  try {                  threadsStarted.await();
                     Thread.sleep(SMALL_DELAY_MS);  
817                      q.put(one);                      q.put(one);
818                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
819    
820          joinPool(executor);          joinPool(executor);
821      }      }
# Line 914  Line 823 
823      /**      /**
824       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
825       */       */
826      public void testSerialization() {      public void testSerialization() throws Exception {
827          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
828    
         try {  
829              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
830              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
831              out.writeObject(q);              out.writeObject(q);
# Line 929  Line 837 
837              assertEquals(q.size(), r.size());              assertEquals(q.size(), r.size());
838              while (!q.isEmpty())              while (!q.isEmpty())
839                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
         } catch(Exception e){  
             unexpectedException();  
         }  
840      }      }
841    
842      /**      /**
# Line 942  Line 847 
847          try {          try {
848              q.drainTo(null);              q.drainTo(null);
849              shouldThrow();              shouldThrow();
850          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
851      }      }
852    
853      /**      /**
# Line 954  Line 858 
858          try {          try {
859              q.drainTo(q);              q.drainTo(q);
860              shouldThrow();              shouldThrow();
861          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
862      }      }
863    
864      /**      /**
# Line 969  Line 872 
872          assertEquals(l.size(), SIZE);          assertEquals(l.size(), SIZE);
873          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
874              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
875            q.add(zero);
876            q.add(one);
877            assertFalse(q.isEmpty());
878            assertTrue(q.contains(zero));
879            assertTrue(q.contains(one));
880            l.clear();
881            q.drainTo(l);
882            assertEquals(q.size(), 0);
883            assertEquals(l.size(), 2);
884            for (int i = 0; i < 2; ++i)
885                assertEquals(l.get(i), new Integer(i));
886      }      }
887    
888      /**      /**
889       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
890       */       */
891      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
892          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
893          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
894                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
895                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
896                      } catch (InterruptedException ie){              }});
897                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
898              t.start();              t.start();
899              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
900              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 902 
902              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
903                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
904              t.join();              t.join();
905              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
906      }      }
907    
908      /**      /**
# Line 1007  Line 913 
913          try {          try {
914              q.drainTo(null, 0);              q.drainTo(null, 0);
915              shouldThrow();              shouldThrow();
916          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
917      }      }
918    
919      /**      /**
# Line 1019  Line 924 
924          try {          try {
925              q.drainTo(q, 0);              q.drainTo(q, 0);
926              shouldThrow();              shouldThrow();
927          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
928      }      }
929    
930      /**      /**
931       * drainTo(c, n) empties first max {n, size} elements of queue into c       * drainTo(c, n) empties first min(n, size) elements of queue into c
932       */       */
933      public void testDrainToN() {      public void testDrainToN() {
934            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
935          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
936              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
937                    assertTrue(q.offer(new Integer(j)));
938              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
939              q.drainTo(l, i);              q.drainTo(l, i);
940              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
             assertEquals(q.size(), SIZE-k);  
941              assertEquals(l.size(), k);              assertEquals(l.size(), k);
942                assertEquals(q.size(), SIZE-k);
943              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
944                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
945                while (q.poll() != null) ;
946          }          }
947      }      }
948    
   
949  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8