[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.29, Wed Aug 25 00:07:02 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) {}
         catch (NullPointerException success) {}  
226      }      }
227      /**      /**
228       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
# Line 245  Line 236 
236                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
237              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
238              shouldThrow();              shouldThrow();
239          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
240      }      }
241      /**      /**
242       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
# Line 259  Line 249 
249                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
250              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
251              shouldThrow();              shouldThrow();
252          }          } catch (IllegalStateException success) {}
         catch (IllegalStateException success) {}  
253      }      }
254      /**      /**
255       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
256       */       */
257      public void testAddAll5() {      public void testAddAll5() {
         try {  
258              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
259              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
260              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 277  Line 265 
265              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
266                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
267          }          }
         finally {}  
     }  
268    
269      /**      /**
270       *  put(null) throws NPE       *  put(null) throws NPE
271       */       */
272       public void testPutNull() {      public void testPutNull() throws InterruptedException {
273          try {          try {
274              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
275              q.put(null);              q.put(null);
276              shouldThrow();              shouldThrow();
277          }          } catch (NullPointerException success) {}
         catch (NullPointerException success){  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
278       }       }
279    
280      /**      /**
281       * all elements successfully put are contained       * all elements successfully put are contained
282       */       */
283       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
284               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
285               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
286                   Integer I = new Integer(i);                   Integer I = new Integer(i);
# Line 309  Line 289 
289               }               }
290               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
291           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
292    
293      /**      /**
294       * put blocks interruptibly if full       * put blocks interruptibly if full
295       */       */
296      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
297          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
298                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
299                      int added = 0;              public void realRun() throws InterruptedException {
300                    for (int i = 0; i < SIZE; ++i)
301                        q.put(i);
302                    assertEquals(SIZE, q.size());
303                    assertEquals(0, q.remainingCapacity());
304                      try {                      try {
305                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                      q.put(99);
306                          for (int i = 0; i < SIZE; ++i) {                      shouldThrow();
307                              q.put(new Integer(i));                  } catch (InterruptedException success) {}
                             ++added;  
                         }  
                         q.put(new Integer(SIZE));  
                         threadShouldThrow();  
                     } catch (InterruptedException ie){  
                         threadAssertEquals(added, SIZE);  
                     }  
308                  }});                  }});
309          try {  
310              t.start();              t.start();
311             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
312             t.interrupt();             t.interrupt();
313             t.join();             t.join();
314          }          assertEquals(SIZE, q.size());
315          catch (InterruptedException ie) {          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
316      }      }
317    
318      /**      /**
319       * put blocks waiting for take when full       * put blocks waiting for take when full
320       */       */
321      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
322          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
323          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
324                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
325                      int added = 0;              public void realRun() throws InterruptedException {
326                      try {                  for (int i = 0; i < capacity + 1; i++)
327                          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);  
                     }  
                 }  
             });  
328          try {          try {
329                        q.put(99);
330                        shouldThrow();
331                    } catch (InterruptedException success) {}
332                }});
333    
334              t.start();              t.start();
335              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
336              q.take();          assertEquals(q.remainingCapacity(), 0);
337            assertEquals(0, q.take());
338            Thread.sleep(SHORT_DELAY_MS);
339              t.interrupt();              t.interrupt();
340              t.join();              t.join();
341          } catch (Exception e){          assertEquals(q.remainingCapacity(), 0);
             unexpectedException();  
         }  
342      }      }
343    
344      /**      /**
345       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
346       */       */
347      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
348          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
349          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
350                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
351                          q.put(new Object());                          q.put(new Object());
352                          q.put(new Object());                          q.put(new Object());
353                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
354                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  try {
355                          threadShouldThrow();                      q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
356                        shouldThrow();
357                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
358                  }              }});
             });  
359    
         try {  
360              t.start();              t.start();
361              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
362              t.interrupt();              t.interrupt();
363              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
364      }      }
365    
366      /**      /**
367       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
368       */       */
369      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
370              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
371              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
372                  assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
             }  
         } catch (InterruptedException e){  
             unexpectedException();  
373          }          }
374      }      }
375    
376      /**      /**
377       * take blocks interruptibly when empty       * take blocks interruptibly when empty
378       */       */
379      public void testTakeFromEmpty() {      public void testTakeFromEmpty() throws InterruptedException {
380          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
381          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
382                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
383                          q.take();                          q.take();
384                          threadShouldThrow();              }};
385                      } catch (InterruptedException success){ }  
                 }  
             });  
         try {  
386              t.start();              t.start();
387              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
388              t.interrupt();              t.interrupt();
389              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
390      }      }
391    
392      /**      /**
393       * Take removes existing elements until empty, then blocks interruptibly       * Take removes existing elements until empty, then blocks interruptibly
394       */       */
395      public void testBlockingTake() {      public void testBlockingTake() throws InterruptedException {
396          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = populatedQueue(SIZE);
397                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
398                      try {              public void realRun() throws InterruptedException {
                         ArrayBlockingQueue q = populatedQueue(SIZE);  
399                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
400                              threadAssertEquals(i, ((Integer)q.take()).intValue());                      assertEquals(i, q.take());
401                          }                          }
402                    try {
403                          q.take();                          q.take();
404                          threadShouldThrow();                      shouldThrow();
405                      } catch (InterruptedException success){                  } catch (InterruptedException success) {}
                     }  
406                  }});                  }});
407          try {  
408              t.start();              t.start();
409              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
410              t.interrupt();              t.interrupt();
411              t.join();              t.join();
412          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
413    
414    
415      /**      /**
# Line 476  Line 418 
418      public void testPoll() {      public void testPoll() {
419          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
420          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
421              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
422          }          }
423          assertNull(q.poll());          assertNull(q.poll());
424      }      }
# Line 484  Line 426 
426      /**      /**
427       * timed pool with zero timeout succeeds when non-empty, else times out       * timed pool with zero timeout succeeds when non-empty, else times out
428       */       */
429      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
430              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
431              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
432                  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();  
433          }          }
434            assertNull(q.poll(0, MILLISECONDS));
435      }      }
436    
437      /**      /**
438       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed pool with nonzero timeout succeeds when non-empty, else times out
439       */       */
440      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
441              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
442              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
443                  assertEquals(i, ((Integer)q.poll(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();  
444          }          }
445            assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
446      }      }
447    
448      /**      /**
449       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
450       * returning timeout status       * returning timeout status
451       */       */
452      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
453          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
454                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
455                          ArrayBlockingQueue q = populatedQueue(SIZE);                          ArrayBlockingQueue q = populatedQueue(SIZE);
456                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
457                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;
                         }  
                         threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
                     } catch (InterruptedException success){  
458                      }                      }
                 }});  
459          try {          try {
460                        q.poll(SMALL_DELAY_MS, MILLISECONDS);
461                        shouldThrow();
462                    } catch (InterruptedException success) {}
463                }});
464    
465              t.start();              t.start();
466              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
467              t.interrupt();              t.interrupt();
468              t.join();              t.join();
469          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
470    
471      /**      /**
472       *  timed poll before a delayed offer fails; after offer succeeds;       *  timed poll before a delayed offer fails; after offer succeeds;
473       *  on interruption throws       *  on interruption throws
474       */       */
475      public void testTimedPollWithOffer() {      public void testTimedPollWithOffer() throws InterruptedException {
476          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
477          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
478                  public void run() {              public void realRun() throws InterruptedException {
479                    assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
480                    assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
481                      try {                      try {
482                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                      q.poll(LONG_DELAY_MS, MILLISECONDS);
483                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                      shouldThrow();
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);  
                         threadShouldThrow();  
484                      } catch (InterruptedException success) { }                      } catch (InterruptedException success) { }
485                  }              }});
486              });  
         try {  
487              t.start();              t.start();
488              Thread.sleep(SMALL_DELAY_MS);              Thread.sleep(SMALL_DELAY_MS);
489              assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
490              t.interrupt();              t.interrupt();
491              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
492      }      }
493    
494    
# Line 572  Line 498 
498      public void testPeek() {      public void testPeek() {
499          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
500          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
501              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
502              q.poll();              assertEquals(i, q.poll());
503              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
504                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
505          }          }
506          assertNull(q.peek());          assertNull(q.peek());
507      }      }
# Line 586  Line 512 
512      public void testElement() {      public void testElement() {
513          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
514          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
515              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
516              q.poll();              assertEquals(i, q.poll());
517          }          }
518          try {          try {
519              q.element();              q.element();
520              shouldThrow();              shouldThrow();
521          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
522      }      }
523    
524      /**      /**
# Line 602  Line 527 
527      public void testRemove() {      public void testRemove() {
528          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
529          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
530              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
531          }          }
532          try {          try {
533              q.remove();              q.remove();
534              shouldThrow();              shouldThrow();
535          } catch (NoSuchElementException success){          } catch (NoSuchElementException success) {}
         }  
536      }      }
537    
538      /**      /**
# Line 633  Line 557 
557          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
558          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
559              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
560              q.poll();              assertEquals(i, q.poll());
561              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
562          }          }
563      }      }
# Line 649  Line 573 
573          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
574          q.add(one);          q.add(one);
575          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
576            assertTrue(q.contains(one));
577          q.clear();          q.clear();
578          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
579      }      }
# Line 705  Line 630 
630      /**      /**
631       *  toArray contains all elements       *  toArray contains all elements
632       */       */
633      public void testToArray() {      public void testToArray() throws InterruptedException {
634          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
635          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
636          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
637              assertEquals(o[i], q.take());              assertEquals(o[i], q.take());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
638      }      }
639    
640      /**      /**
641       * toArray(a) contains all elements       * toArray(a) contains all elements
642       */       */
643      public void testToArray2() {      public void testToArray2() throws InterruptedException {
644          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
645          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
646          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
         try {  
647              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
648                  assertEquals(ints[i], q.take());                  assertEquals(ints[i], q.take());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
649      }      }
650    
651      /**      /**
652       * toArray(null) throws NPE       * toArray(null) throws NPE
653       */       */
654      public void testToArray_BadArg() {      public void testToArray_BadArg() {
         try {  
655              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
656            try {
657              Object o[] = q.toArray(null);              Object o[] = q.toArray(null);
658              shouldThrow();              shouldThrow();
659          } catch(NullPointerException success){}          } catch(NullPointerException success){}
660      }      }
661    
662      /**      /**
663       * toArray with incompatable array type throws CCE       * toArray with incompatible array type throws CCE
664       */       */
665      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
666              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
667            try {
668              Object o[] = q.toArray(new String[10] );              Object o[] = q.toArray(new String[10] );
669              shouldThrow();              shouldThrow();
670          } catch(ArrayStoreException  success){}          } catch(ArrayStoreException  success){}
# Line 757  Line 674 
674      /**      /**
675       * iterator iterates through all elements       * iterator iterates through all elements
676       */       */
677      public void testIterator() {      public void testIterator() throws InterruptedException {
678          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
679          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
680              while(it.hasNext()){              while(it.hasNext()){
681                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
682              }              }
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
683      }      }
684    
685      /**      /**
# Line 783  Line 696 
696          it.remove();          it.remove();
697    
698          it = q.iterator();          it = q.iterator();
699          assertEquals(it.next(), one);          assertSame(it.next(), one);
700          assertEquals(it.next(), three);          assertSame(it.next(), three);
701          assertFalse(it.hasNext());          assertFalse(it.hasNext());
702      }      }
703    
# Line 801  Line 714 
714    
715          int k = 0;          int k = 0;
716          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
717              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
718          }          }
719          assertEquals(3, k);          assertEquals(3, k);
720      }      }
# Line 815  Line 727 
727          q.add(one);          q.add(one);
728          q.add(two);          q.add(two);
729          q.add(three);          q.add(three);
         try {  
730              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
731                  q.remove();                  q.remove();
732                  it.next();                  it.next();
733              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
734          assertEquals(0, q.size());          assertEquals(0, q.size());
735      }      }
736    
# Line 848  Line 755 
755          q.add(one);          q.add(one);
756          q.add(two);          q.add(two);
757          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
758          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
759              public void run() {              public void realRun() throws InterruptedException {
760                  threadAssertFalse(q.offer(three));                  assertFalse(q.offer(three));
761                  try {                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
762                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertEquals(0, q.remainingCapacity());
763                      threadAssertEquals(0, q.remainingCapacity());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
764    
765          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
766              public void run() {              public void realRun() throws InterruptedException {
                 try {  
767                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
768                      threadAssertEquals(one, q.take());                  assertSame(one, q.take());
769                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
770    
771          joinPool(executor);          joinPool(executor);
   
772      }      }
773    
774      /**      /**
# Line 883  Line 777 
777      public void testPollInExecutor() {      public void testPollInExecutor() {
778          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
779          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
780          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
781              public void run() {              public void realRun() throws InterruptedException {
782                  threadAssertNull(q.poll());                  assertNull(q.poll());
783                  try {                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
784                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertTrue(q.isEmpty());
785                      threadAssertTrue(q.isEmpty());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
786    
787          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
788              public void run() {              public void realRun() throws InterruptedException {
                 try {  
789                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
790                      q.put(one);                      q.put(one);
791                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
792    
793          joinPool(executor);          joinPool(executor);
794      }      }
# Line 914  Line 796 
796      /**      /**
797       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
798       */       */
799      public void testSerialization() {      public void testSerialization() throws Exception {
800          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
801    
         try {  
802              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
803              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
804              out.writeObject(q);              out.writeObject(q);
# Line 929  Line 810 
810              assertEquals(q.size(), r.size());              assertEquals(q.size(), r.size());
811              while (!q.isEmpty())              while (!q.isEmpty())
812                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
         } catch(Exception e){  
             unexpectedException();  
         }  
813      }      }
814    
815      /**      /**
# Line 942  Line 820 
820          try {          try {
821              q.drainTo(null);              q.drainTo(null);
822              shouldThrow();              shouldThrow();
823          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
824      }      }
825    
826      /**      /**
# Line 954  Line 831 
831          try {          try {
832              q.drainTo(q);              q.drainTo(q);
833              shouldThrow();              shouldThrow();
834          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
835      }      }
836    
837      /**      /**
# Line 969  Line 845 
845          assertEquals(l.size(), SIZE);          assertEquals(l.size(), SIZE);
846          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
847              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
848            q.add(zero);
849            q.add(one);
850            assertFalse(q.isEmpty());
851            assertTrue(q.contains(zero));
852            assertTrue(q.contains(one));
853            l.clear();
854            q.drainTo(l);
855            assertEquals(q.size(), 0);
856            assertEquals(l.size(), 2);
857            for (int i = 0; i < 2; ++i)
858                assertEquals(l.get(i), new Integer(i));
859      }      }
860    
861      /**      /**
862       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
863       */       */
864      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
865          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
866          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
867                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
868                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
869                      } catch (InterruptedException ie){              }});
870                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
871              t.start();              t.start();
872              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
873              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 875 
875              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
876                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
877              t.join();              t.join();
878              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
879      }      }
880    
881      /**      /**
# Line 1007  Line 886 
886          try {          try {
887              q.drainTo(null, 0);              q.drainTo(null, 0);
888              shouldThrow();              shouldThrow();
889          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
890      }      }
891    
892      /**      /**
# Line 1019  Line 897 
897          try {          try {
898              q.drainTo(q, 0);              q.drainTo(q, 0);
899              shouldThrow();              shouldThrow();
900          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
901      }      }
902    
903      /**      /**
904       * 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
905       */       */
906      public void testDrainToN() {      public void testDrainToN() {
907            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
908          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
909              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
910                    assertTrue(q.offer(new Integer(j)));
911              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
912              q.drainTo(l, i);              q.drainTo(l, i);
913              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
             assertEquals(q.size(), SIZE-k);  
914              assertEquals(l.size(), k);              assertEquals(l.size(), k);
915                assertEquals(q.size(), SIZE-k);
916              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
917                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
918                while (q.poll() != null) ;
919          }          }
920      }      }
921    
   
922  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8