[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.31, Wed Sep 29 12:33:48 2010 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/licenses/publicdomain
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9    
10  import junit.framework.*;  import junit.framework.*;
11  import java.util.*;  import java.util.*;
12  import java.util.concurrent.*;  import java.util.concurrent.*;
13    import static java.util.concurrent.TimeUnit.MILLISECONDS;
14  import java.io.*;  import java.io.*;
15    
16  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
# Line 48  Line 50 
50          try {          try {
51              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              ArrayBlockingQueue q = new ArrayBlockingQueue(0);
52              shouldThrow();              shouldThrow();
53          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
54      }      }
55    
56      /**      /**
# Line 59  Line 60 
60          try {          try {
61              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
62              shouldThrow();              shouldThrow();
63          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
64      }      }
65    
66      /**      /**
# Line 71  Line 71 
71              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
72              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
73              shouldThrow();              shouldThrow();
74          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
75      }      }
76    
77      /**      /**
# Line 85  Line 84 
84                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
85              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
86              shouldThrow();              shouldThrow();
87          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
88      }      }
89    
90      /**      /**
# Line 99  Line 97 
97                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
98              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
99              shouldThrow();              shouldThrow();
100          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
101      }      }
102    
103      /**      /**
104       * Queue contains all elements of collection used to initialize       * Queue contains all elements of collection used to initialize
105       */       */
106      public void testConstructor7() {      public void testConstructor7() {
         try {  
107              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
108              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
109                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
# Line 115  Line 111 
111              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
112                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
113          }          }
         finally {}  
     }  
114    
115      /**      /**
116       * Queue transitions from empty to full when elements added       * Queue transitions from empty to full when elements added
# Line 192  Line 186 
186              }              }
187              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
188              q.add(new Integer(SIZE));              q.add(new Integer(SIZE));
189          } catch (IllegalStateException success){              shouldThrow();
190          }          } catch (IllegalStateException success) {}
191      }      }
192    
193      /**      /**
# Line 204  Line 198 
198              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
199              q.addAll(null);              q.addAll(null);
200              shouldThrow();              shouldThrow();
201          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
202      }      }
203    
204      /**      /**
# Line 216  Line 209 
209              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
210              q.addAll(q);              q.addAll(q);
211              shouldThrow();              shouldThrow();
212          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
213      }      }
214    
215    
# Line 230  Line 222 
222              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
223              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
224              shouldThrow();              shouldThrow();
225            } catch (NullPointerException success) {}
226          }          }
227          catch (NullPointerException success) {}  
     }  
228      /**      /**
229       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
230       * possibly adding some elements       * possibly adding some elements
# Line 245  Line 237 
237                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
238              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
239              shouldThrow();              shouldThrow();
240            } catch (NullPointerException success) {}
241          }          }
242          catch (NullPointerException success) {}  
     }  
243      /**      /**
244       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
245       */       */
# Line 259  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 (IllegalStateException success) {}
255          }          }
256          catch (IllegalStateException success) {}  
     }  
257      /**      /**
258       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
259       */       */
260      public void testAddAll5() {      public void testAddAll5() {
         try {  
261              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
262              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
263              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 277  Line 268 
268              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
269                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
270          }          }
         finally {}  
     }  
271    
272      /**      /**
273       *  put(null) throws NPE       *  put(null) throws NPE
274       */       */
275       public void testPutNull() {      public void testPutNull() throws InterruptedException {
276          try {          try {
277              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
278              q.put(null);              q.put(null);
279              shouldThrow();              shouldThrow();
280          }          } catch (NullPointerException success) {}
         catch (NullPointerException success){  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
281       }       }
282    
283      /**      /**
284       * all elements successfully put are contained       * all elements successfully put are contained
285       */       */
286       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
287               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
288               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
289                   Integer I = new Integer(i);                   Integer I = new Integer(i);
# Line 309  Line 292 
292               }               }
293               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
294           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
295    
296      /**      /**
297       * put blocks interruptibly if full       * put blocks interruptibly if full
298       */       */
299      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
300          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
301                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
302                      int added = 0;              public void realRun() throws InterruptedException {
303                    for (int i = 0; i < SIZE; ++i)
304                        q.put(i);
305                    assertEquals(SIZE, q.size());
306                    assertEquals(0, q.remainingCapacity());
307                      try {                      try {
308                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                      q.put(99);
309                          for (int i = 0; i < SIZE; ++i) {                      shouldThrow();
310                              q.put(new Integer(i));                  } catch (InterruptedException success) {}
                             ++added;  
                         }  
                         q.put(new Integer(SIZE));  
                         threadShouldThrow();  
                     } catch (InterruptedException ie){  
                         threadAssertEquals(added, SIZE);  
                     }  
311                  }});                  }});
312          try {  
313              t.start();              t.start();
314             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
315             t.interrupt();             t.interrupt();
316             t.join();             t.join();
317          }          assertEquals(SIZE, q.size());
318          catch (InterruptedException ie) {          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
319      }      }
320    
321      /**      /**
322       * put blocks waiting for take when full       * put blocks waiting for take when full
323       */       */
324      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
325          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
326          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
327                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
328                      int added = 0;              public void realRun() throws InterruptedException {
329                      try {                  for (int i = 0; i < capacity + 1; i++)
330                          q.put(new Object());                      q.put(i);
                         ++added;  
                         q.put(new Object());  
                         ++added;  
                         q.put(new Object());  
                         ++added;  
                         q.put(new Object());  
                         ++added;  
                         threadShouldThrow();  
                     } catch (InterruptedException e){  
                         threadAssertTrue(added >= 2);  
                     }  
                 }  
             });  
331          try {          try {
332                        q.put(99);
333                        shouldThrow();
334                    } catch (InterruptedException success) {}
335                }});
336    
337              t.start();              t.start();
338              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
339              q.take();          assertEquals(q.remainingCapacity(), 0);
340            assertEquals(0, q.take());
341            Thread.sleep(SHORT_DELAY_MS);
342              t.interrupt();              t.interrupt();
343              t.join();              t.join();
344          } catch (Exception e){          assertEquals(q.remainingCapacity(), 0);
             unexpectedException();  
         }  
345      }      }
346    
347      /**      /**
348       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
349       */       */
350      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
351          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
352          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
353                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
354                          q.put(new Object());                          q.put(new Object());
355                          q.put(new Object());                          q.put(new Object());
356                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
357                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  try {
358                          threadShouldThrow();                      q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
359                        shouldThrow();
360                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
361                  }              }});
             });  
362    
         try {  
363              t.start();              t.start();
364              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
365              t.interrupt();              t.interrupt();
366              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
367      }      }
368    
369      /**      /**
370       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
371       */       */
372      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
373              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
374              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
375                  assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
376          }          }
377      }      }
378    
379      /**      /**
380       * take blocks interruptibly when empty       * take blocks interruptibly when empty
381       */       */
382      public void testTakeFromEmpty() {      public void testTakeFromEmpty() throws InterruptedException {
383          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
384          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
385                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
386                          q.take();                          q.take();
387                          threadShouldThrow();              }};
388                      } catch (InterruptedException success){ }  
                 }  
             });  
         try {  
389              t.start();              t.start();
390              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
391              t.interrupt();              t.interrupt();
392              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
393      }      }
394    
395      /**      /**
396       * Take removes existing elements until empty, then blocks interruptibly       * Take removes existing elements until empty, then blocks interruptibly
397       */       */
398      public void testBlockingTake() {      public void testBlockingTake() throws InterruptedException {
399          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = populatedQueue(SIZE);
400                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
401                      try {              public void realRun() throws InterruptedException {
                         ArrayBlockingQueue q = populatedQueue(SIZE);  
402                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
403                              threadAssertEquals(i, ((Integer)q.take()).intValue());                      assertEquals(i, q.take());
404                          }                          }
405                    try {
406                          q.take();                          q.take();
407                          threadShouldThrow();                      shouldThrow();
408                      } catch (InterruptedException success){                  } catch (InterruptedException success) {}
                     }  
409                  }});                  }});
410          try {  
411              t.start();              t.start();
412              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
413              t.interrupt();              t.interrupt();
414              t.join();              t.join();
415          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
416    
417    
418      /**      /**
# Line 476  Line 421 
421      public void testPoll() {      public void testPoll() {
422          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
423          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
424              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
425          }          }
426          assertNull(q.poll());          assertNull(q.poll());
427      }      }
# Line 484  Line 429 
429      /**      /**
430       * timed pool with zero timeout succeeds when non-empty, else times out       * timed pool with zero timeout succeeds when non-empty, else times out
431       */       */
432      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
433              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
434              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
435                  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();  
436          }          }
437            assertNull(q.poll(0, MILLISECONDS));
438      }      }
439    
440      /**      /**
441       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed pool with nonzero timeout succeeds when non-empty, else times out
442       */       */
443      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
444              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
445              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
446                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());              assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
             }  
             assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
         } catch (InterruptedException e){  
             unexpectedException();  
447          }          }
448            assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
449      }      }
450    
451      /**      /**
452       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
453       * returning timeout status       * returning timeout status
454       */       */
455      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
456          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
457                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
458                          ArrayBlockingQueue q = populatedQueue(SIZE);                          ArrayBlockingQueue q = populatedQueue(SIZE);
459                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
460                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;
461                          }                          }
                         threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
                     } catch (InterruptedException success){  
                     }  
                 }});  
462          try {          try {
463                        q.poll(SMALL_DELAY_MS, MILLISECONDS);
464                        shouldThrow();
465                    } catch (InterruptedException success) {}
466                }});
467    
468              t.start();              t.start();
469              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
470              t.interrupt();              t.interrupt();
471              t.join();              t.join();
472          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
473    
474      /**      /**
475       *  timed poll before a delayed offer fails; after offer succeeds;       *  timed poll before a delayed offer fails; after offer succeeds;
476       *  on interruption throws       *  on interruption throws
477       */       */
478      public void testTimedPollWithOffer() {      public void testTimedPollWithOffer() throws InterruptedException {
479          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
480          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
481                  public void run() {              public void realRun() throws InterruptedException {
482                      try {                      try {
483                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                      assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
484                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                      assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
485                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                      q.poll(LONG_DELAY_MS, MILLISECONDS);
486                          threadShouldThrow();                      shouldThrow();
487                      } catch (InterruptedException success) { }                      } catch (InterruptedException success) { }
488                  }              }});
489              });  
         try {  
490              t.start();              t.start();
491              Thread.sleep(SMALL_DELAY_MS);              Thread.sleep(SMALL_DELAY_MS);
492              assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
493              t.interrupt();              t.interrupt();
494              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
495      }      }
496    
497    
# Line 572  Line 501 
501      public void testPeek() {      public void testPeek() {
502          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
503          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
504              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
505              q.poll();              assertEquals(i, q.poll());
506              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
507                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
508          }          }
509          assertNull(q.peek());          assertNull(q.peek());
510      }      }
# Line 586  Line 515 
515      public void testElement() {      public void testElement() {
516          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
517          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
518              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
519              q.poll();              assertEquals(i, q.poll());
520          }          }
521          try {          try {
522              q.element();              q.element();
523              shouldThrow();              shouldThrow();
524          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
525      }      }
526    
527      /**      /**
# Line 602  Line 530 
530      public void testRemove() {      public void testRemove() {
531          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
532          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
533              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
534          }          }
535          try {          try {
536              q.remove();              q.remove();
537              shouldThrow();              shouldThrow();
538          } catch (NoSuchElementException success){          } catch (NoSuchElementException success) {}
         }  
539      }      }
540    
541      /**      /**
# Line 633  Line 560 
560          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
561          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
562              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
563              q.poll();              assertEquals(i, q.poll());
564              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
565          }          }
566      }      }
# Line 649  Line 576 
576          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
577          q.add(one);          q.add(one);
578          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
579            assertTrue(q.contains(one));
580          q.clear();          q.clear();
581          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
582      }      }
# Line 705  Line 633 
633      /**      /**
634       *  toArray contains all elements       *  toArray contains all elements
635       */       */
636      public void testToArray() {      public void testToArray() throws InterruptedException {
637          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
638          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
639          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
640              assertEquals(o[i], q.take());              assertEquals(o[i], q.take());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
641      }      }
642    
643      /**      /**
644       * toArray(a) contains all elements       * toArray(a) contains all elements
645       */       */
646      public void testToArray2() {      public void testToArray2() throws InterruptedException {
647          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
648          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
649          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
         try {  
650              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
651                  assertEquals(ints[i], q.take());                  assertEquals(ints[i], q.take());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
652      }      }
653    
654      /**      /**
655       * toArray(null) throws NPE       * toArray(null) throws NPE
656       */       */
657      public void testToArray_BadArg() {      public void testToArray_BadArg() {
         try {  
658              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
659            try {
660              Object o[] = q.toArray(null);              Object o[] = q.toArray(null);
661              shouldThrow();              shouldThrow();
662          } catch(NullPointerException success){}          } catch(NullPointerException success){}
663      }      }
664    
665      /**      /**
666       * toArray with incompatable array type throws CCE       * toArray with incompatible array type throws CCE
667       */       */
668      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
669              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
670            try {
671              Object o[] = q.toArray(new String[10] );              Object o[] = q.toArray(new String[10] );
672              shouldThrow();              shouldThrow();
673          } catch(ArrayStoreException  success){}          } catch(ArrayStoreException  success){}
# Line 757  Line 677 
677      /**      /**
678       * iterator iterates through all elements       * iterator iterates through all elements
679       */       */
680      public void testIterator() {      public void testIterator() throws InterruptedException {
681          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
682          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
683              while(it.hasNext()){              while(it.hasNext()){
684                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
685              }              }
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
686      }      }
687    
688      /**      /**
# Line 783  Line 699 
699          it.remove();          it.remove();
700    
701          it = q.iterator();          it = q.iterator();
702          assertEquals(it.next(), one);          assertSame(it.next(), one);
703          assertEquals(it.next(), three);          assertSame(it.next(), three);
704          assertFalse(it.hasNext());          assertFalse(it.hasNext());
705      }      }
706    
# Line 801  Line 717 
717    
718          int k = 0;          int k = 0;
719          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
720              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
721          }          }
722          assertEquals(3, k);          assertEquals(3, k);
723      }      }
# Line 815  Line 730 
730          q.add(one);          q.add(one);
731          q.add(two);          q.add(two);
732          q.add(three);          q.add(three);
         try {  
733              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
734                  q.remove();                  q.remove();
735                  it.next();                  it.next();
736              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
737          assertEquals(0, q.size());          assertEquals(0, q.size());
738      }      }
739    
# Line 848  Line 758 
758          q.add(one);          q.add(one);
759          q.add(two);          q.add(two);
760          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
761          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
762              public void run() {              public void realRun() throws InterruptedException {
763                  threadAssertFalse(q.offer(three));                  assertFalse(q.offer(three));
764                  try {                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
765                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertEquals(0, q.remainingCapacity());
766                      threadAssertEquals(0, q.remainingCapacity());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
767    
768          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
769              public void run() {              public void realRun() throws InterruptedException {
                 try {  
770                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
771                      threadAssertEquals(one, q.take());                  assertSame(one, q.take());
772                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
773    
774          joinPool(executor);          joinPool(executor);
   
775      }      }
776    
777      /**      /**
# Line 883  Line 780 
780      public void testPollInExecutor() {      public void testPollInExecutor() {
781          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
782          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
783          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
784              public void run() {              public void realRun() throws InterruptedException {
785                  threadAssertNull(q.poll());                  assertNull(q.poll());
786                  try {                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
787                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertTrue(q.isEmpty());
788                      threadAssertTrue(q.isEmpty());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
789    
790          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
791              public void run() {              public void realRun() throws InterruptedException {
                 try {  
792                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
793                      q.put(one);                      q.put(one);
794                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
795    
796          joinPool(executor);          joinPool(executor);
797      }      }
# Line 914  Line 799 
799      /**      /**
800       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
801       */       */
802      public void testSerialization() {      public void testSerialization() throws Exception {
803          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
804    
         try {  
805              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
806              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
807              out.writeObject(q);              out.writeObject(q);
# Line 929  Line 813 
813              assertEquals(q.size(), r.size());              assertEquals(q.size(), r.size());
814              while (!q.isEmpty())              while (!q.isEmpty())
815                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
         } catch(Exception e){  
             unexpectedException();  
         }  
816      }      }
817    
818      /**      /**
# Line 942  Line 823 
823          try {          try {
824              q.drainTo(null);              q.drainTo(null);
825              shouldThrow();              shouldThrow();
826          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
827      }      }
828    
829      /**      /**
# Line 954  Line 834 
834          try {          try {
835              q.drainTo(q);              q.drainTo(q);
836              shouldThrow();              shouldThrow();
837          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
838      }      }
839    
840      /**      /**
# Line 969  Line 848 
848          assertEquals(l.size(), SIZE);          assertEquals(l.size(), SIZE);
849          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
850              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
851            q.add(zero);
852            q.add(one);
853            assertFalse(q.isEmpty());
854            assertTrue(q.contains(zero));
855            assertTrue(q.contains(one));
856            l.clear();
857            q.drainTo(l);
858            assertEquals(q.size(), 0);
859            assertEquals(l.size(), 2);
860            for (int i = 0; i < 2; ++i)
861                assertEquals(l.get(i), new Integer(i));
862      }      }
863    
864      /**      /**
865       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
866       */       */
867      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
868          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
869          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
870                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
871                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
872                      } catch (InterruptedException ie){              }});
873                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
874              t.start();              t.start();
875              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
876              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 878 
878              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
879                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
880              t.join();              t.join();
881              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
882      }      }
883    
884      /**      /**
# Line 1007  Line 889 
889          try {          try {
890              q.drainTo(null, 0);              q.drainTo(null, 0);
891              shouldThrow();              shouldThrow();
892          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
893      }      }
894    
895      /**      /**
# Line 1019  Line 900 
900          try {          try {
901              q.drainTo(q, 0);              q.drainTo(q, 0);
902              shouldThrow();              shouldThrow();
903          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
904      }      }
905    
906      /**      /**
907       * drainTo(c, n) empties first max {n, size} elements of queue into c       * drainTo(c, n) empties first max {n, size} elements of queue into c
908       */       */
909      public void testDrainToN() {      public void testDrainToN() {
910            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
911          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
912              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
913                    assertTrue(q.offer(new Integer(j)));
914              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
915              q.drainTo(l, i);              q.drainTo(l, i);
916              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
             assertEquals(q.size(), SIZE-k);  
917              assertEquals(l.size(), k);              assertEquals(l.size(), k);
918                assertEquals(q.size(), SIZE-k);
919              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
920                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
921                while (q.poll() != null) ;
922          }          }
923      }      }
924    
   
925  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8