[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.16, Sat Nov 21 02:33:20 2009 UTC revision 1.37, Thu Oct 28 22:20:47 2010 UTC
# Line 14  Line 14 
14  import java.io.*;  import java.io.*;
15    
16  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
17    
18        public static class Fair extends BlockingQueueTest {
19            protected BlockingQueue emptyCollection() {
20                return new ArrayBlockingQueue(20, true);
21            }
22        }
23    
24        public static class NonFair extends BlockingQueueTest {
25            protected BlockingQueue emptyCollection() {
26                return new ArrayBlockingQueue(20, false);
27            }
28        }
29    
30      public static void main(String[] args) {      public static void main(String[] args) {
31          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
32      }      }
33    
34      public static Test suite() {      public static Test suite() {
35          return new TestSuite(ArrayBlockingQueueTest.class);          return newTestSuite(ArrayBlockingQueueTest.class,
36                                new Fair().testSuite(),
37                                new NonFair().testSuite());
38      }      }
39    
40      /**      /**
# Line 50  Line 66 
66          try {          try {
67              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              ArrayBlockingQueue q = new ArrayBlockingQueue(0);
68              shouldThrow();              shouldThrow();
69          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
70      }      }
71    
72      /**      /**
# Line 61  Line 76 
76          try {          try {
77              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
78              shouldThrow();              shouldThrow();
79          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
80      }      }
81    
82      /**      /**
# Line 73  Line 87 
87              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
88              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
89              shouldThrow();              shouldThrow();
90          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
91      }      }
92    
93      /**      /**
# Line 87  Line 100 
100                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
101              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
102              shouldThrow();              shouldThrow();
103          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
104      }      }
105    
106      /**      /**
# Line 101  Line 113 
113                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
114              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
115              shouldThrow();              shouldThrow();
116          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
117      }      }
118    
119      /**      /**
120       * Queue contains all elements of collection used to initialize       * Queue contains all elements of collection used to initialize
121       */       */
122      public void testConstructor7() {      public void testConstructor7() {
         try {  
123              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
124              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
125                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
# Line 117  Line 127 
127              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
128                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
129          }          }
         finally {}  
     }  
130    
131      /**      /**
132       * Queue transitions from empty to full when elements added       * Queue transitions from empty to full when elements added
# Line 194  Line 202 
202              }              }
203              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
204              q.add(new Integer(SIZE));              q.add(new Integer(SIZE));
205          } catch (IllegalStateException success) {              shouldThrow();
206          }          } catch (IllegalStateException success) {}
207      }      }
208    
209      /**      /**
# Line 206  Line 214 
214              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
215              q.addAll(null);              q.addAll(null);
216              shouldThrow();              shouldThrow();
217          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
218      }      }
219    
220      /**      /**
# Line 218  Line 225 
225              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
226              q.addAll(q);              q.addAll(q);
227              shouldThrow();              shouldThrow();
228          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
229      }      }
230    
231    
# Line 232  Line 238 
238              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
239              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
240              shouldThrow();              shouldThrow();
241            } catch (NullPointerException success) {}
242          }          }
243          catch (NullPointerException success) {}  
     }  
244      /**      /**
245       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
246       * possibly adding some elements       * possibly adding some elements
# Line 247  Line 253 
253                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
254              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
255              shouldThrow();              shouldThrow();
256            } catch (NullPointerException success) {}
257          }          }
258          catch (NullPointerException success) {}  
     }  
259      /**      /**
260       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
261       */       */
# Line 261  Line 267 
267                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
268              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
269              shouldThrow();              shouldThrow();
270            } catch (IllegalStateException success) {}
271          }          }
272          catch (IllegalStateException success) {}  
     }  
273      /**      /**
274       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
275       */       */
276      public void testAddAll5() {      public void testAddAll5() {
         try {  
277              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
278              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
279              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 279  Line 284 
284              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
285                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
286          }          }
         finally {}  
     }  
287    
288      /**      /**
289       *  put(null) throws NPE       *  put(null) throws NPE
290       */       */
291       public void testPutNull() {      public void testPutNull() throws InterruptedException {
292          try {          try {
293              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
294              q.put(null);              q.put(null);
295              shouldThrow();              shouldThrow();
296          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
297       }       }
298    
299      /**      /**
300       * all elements successfully put are contained       * all elements successfully put are contained
301       */       */
302       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
303               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
304               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
305                   Integer I = new Integer(i);                   Integer I = new Integer(i);
# Line 311  Line 308 
308               }               }
309               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
310           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
311    
312      /**      /**
313       * put blocks interruptibly if full       * put blocks interruptibly if full
314       */       */
315      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
316          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
317          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
318                  public void run() {              public void realRun() throws InterruptedException {
319                      int added = 0;                  for (int i = 0; i < SIZE; ++i)
320                        q.put(i);
321                    assertEquals(SIZE, q.size());
322                    assertEquals(0, q.remainingCapacity());
323                      try {                      try {
324                          for (int i = 0; i < SIZE; ++i) {                      q.put(99);
325                              q.put(new Integer(i));                      shouldThrow();
326                              ++added;                  } catch (InterruptedException success) {}
                         }  
                         q.put(new Integer(SIZE));  
                         threadShouldThrow();  
                     } catch (InterruptedException ie) {  
                         threadAssertEquals(added, SIZE);  
                     }  
327                  }});                  }});
328          try {  
329              t.start();              t.start();
330             Thread.sleep(MEDIUM_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
331             t.interrupt();             t.interrupt();
332             t.join();             t.join();
333          }          assertEquals(SIZE, q.size());
334          catch (InterruptedException ie) {          assertEquals(0, q.remainingCapacity());
             unexpectedException();  
         }  
335      }      }
336    
337      /**      /**
338       * put blocks waiting for take when full       * put blocks waiting for take when full
339       */       */
340      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
341          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
342          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
343                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
344                      int added = 0;              public void realRun() throws InterruptedException {
345                      try {                  for (int i = 0; i < capacity + 1; i++)
346                          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);  
                     }  
                 }  
             });  
347          try {          try {
348                        q.put(99);
349                        shouldThrow();
350                    } catch (InterruptedException success) {}
351                }});
352    
353              t.start();              t.start();
354              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
355              q.take();          assertEquals(q.remainingCapacity(), 0);
356            assertEquals(0, q.take());
357            Thread.sleep(SHORT_DELAY_MS);
358              t.interrupt();              t.interrupt();
359              t.join();              t.join();
360          } catch (Exception e) {          assertEquals(q.remainingCapacity(), 0);
             unexpectedException();  
         }  
361      }      }
362    
363      /**      /**
364       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
365       */       */
366      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
367          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
368          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
369                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
370                          q.put(new Object());                          q.put(new Object());
371                          q.put(new Object());                          q.put(new Object());
372                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
373                    try {
374                          q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);                          q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
375                          threadShouldThrow();                      shouldThrow();
376                      } catch (InterruptedException success) {}                      } catch (InterruptedException success) {}
377                  }              }});
             });  
378    
         try {  
379              t.start();              t.start();
380              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
381              t.interrupt();              t.interrupt();
382              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
383      }      }
384    
385      /**      /**
386       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
387       */       */
388      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
389              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
390              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
391                  assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
             }  
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
     }  
   
     /**  
      * take blocks interruptibly when empty  
      */  
     public void testTakeFromEmpty() {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         q.take();  
                         threadShouldThrow();  
                     } catch (InterruptedException success) { }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         } catch (Exception e) {  
             unexpectedException();  
392          }          }
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 478  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      }      }
428    
429      /**      /**
430       * timed pool with zero timeout succeeds when non-empty, else times out       * timed poll 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, MILLISECONDS)).intValue());              assertEquals(i, q.poll(0, MILLISECONDS));
436              }              }
437              assertNull(q.poll(0, MILLISECONDS));              assertNull(q.poll(0, MILLISECONDS));
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
438      }      }
439    
440      /**      /**
441       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed poll 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, MILLISECONDS)).intValue());              assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
447              }              }
448              assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));              assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
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, MILLISECONDS)).intValue());                      assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;
                         }  
                         threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));  
                     } catch (InterruptedException success) {  
461                      }                      }
                 }});  
462          try {          try {
463              t.start();                      q.poll(SMALL_DELAY_MS, MILLISECONDS);
464              Thread.sleep(SHORT_DELAY_MS);                      shouldThrow();
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
   
     /**  
      *  timed poll before a delayed offer fails; after offer succeeds;  
      *  on interruption throws  
      */  
     public void testTimedPollWithOffer() {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));  
                         q.poll(LONG_DELAY_MS, MILLISECONDS);  
                         q.poll(LONG_DELAY_MS, MILLISECONDS);  
                         threadShouldThrow();  
465                      } catch (InterruptedException success) { }                      } catch (InterruptedException success) { }
466                  }              }});
467              });  
         try {  
468              t.start();              t.start();
469              Thread.sleep(SMALL_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
             assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));  
470              t.interrupt();              t.interrupt();
471              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
472      }      }
473    
   
474      /**      /**
475       * peek returns next element, or null if empty       * peek returns next element, or null if empty
476       */       */
477      public void testPeek() {      public void testPeek() {
478          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
479          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
480              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
481              q.poll();              assertEquals(i, q.poll());
482              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
483                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
484          }          }
485          assertNull(q.peek());          assertNull(q.peek());
486      }      }
# Line 588  Line 491 
491      public void testElement() {      public void testElement() {
492          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
493          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
494              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
495              q.poll();              assertEquals(i, q.poll());
496          }          }
497          try {          try {
498              q.element();              q.element();
499              shouldThrow();              shouldThrow();
500          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
501      }      }
502    
503      /**      /**
# Line 604  Line 506 
506      public void testRemove() {      public void testRemove() {
507          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
508          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
509              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
510          }          }
511          try {          try {
512              q.remove();              q.remove();
513              shouldThrow();              shouldThrow();
514          } catch (NoSuchElementException success) {          } catch (NoSuchElementException success) {}
         }  
515      }      }
516    
517      /**      /**
# Line 635  Line 536 
536          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
537          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
538              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
539              q.poll();              assertEquals(i, q.poll());
540              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
541          }          }
542      }      }
# Line 708  Line 609 
609      /**      /**
610       *  toArray contains all elements       *  toArray contains all elements
611       */       */
612      public void testToArray() {      public void testToArray() throws InterruptedException {
613          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
614          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
615          for (int i = 0; i < o.length; i++)          for (int i = 0; i < o.length; i++)
616              assertEquals(o[i], q.take());              assertEquals(o[i], q.take());
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
617      }      }
618    
619      /**      /**
620       * toArray(a) contains all elements       * toArray(a) contains all elements
621       */       */
622      public void testToArray2() {      public void testToArray2() throws InterruptedException {
623          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
624          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
625          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
         try {  
626              for (int i = 0; i < ints.length; i++)              for (int i = 0; i < ints.length; i++)
627                  assertEquals(ints[i], q.take());                  assertEquals(ints[i], q.take());
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
628      }      }
629    
630      /**      /**
631       * toArray(null) throws NPE       * toArray(null) throws NPE
632       */       */
633      public void testToArray_BadArg() {      public void testToArray_BadArg() {
         try {  
634              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
635            try {
636              Object o[] = q.toArray(null);              Object o[] = q.toArray(null);
637              shouldThrow();              shouldThrow();
638          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
# Line 749  Line 642 
642       * toArray with incompatible array type throws CCE       * toArray with incompatible array type throws CCE
643       */       */
644      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
645              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
646            try {
647              Object o[] = q.toArray(new String[10] );              Object o[] = q.toArray(new String[10] );
648              shouldThrow();              shouldThrow();
649          } catch (ArrayStoreException  success) {}          } catch (ArrayStoreException  success) {}
# Line 760  Line 653 
653      /**      /**
654       * iterator iterates through all elements       * iterator iterates through all elements
655       */       */
656      public void testIterator() {      public void testIterator() throws InterruptedException {
657          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
658          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
659              while (it.hasNext()) {              while (it.hasNext()) {
660                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
661              }              }
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
662      }      }
663    
664      /**      /**
# Line 786  Line 675 
675          it.remove();          it.remove();
676    
677          it = q.iterator();          it = q.iterator();
678          assertEquals(it.next(), one);          assertSame(it.next(), one);
679          assertEquals(it.next(), three);          assertSame(it.next(), three);
680          assertFalse(it.hasNext());          assertFalse(it.hasNext());
681      }      }
682    
# Line 804  Line 693 
693    
694          int k = 0;          int k = 0;
695          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
696              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
697          }          }
698          assertEquals(3, k);          assertEquals(3, k);
699      }      }
# Line 818  Line 706 
706          q.add(one);          q.add(one);
707          q.add(two);          q.add(two);
708          q.add(three);          q.add(three);
         try {  
709              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
710                  q.remove();                  q.remove();
711                  it.next();                  it.next();
712              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
713          assertEquals(0, q.size());          assertEquals(0, q.size());
714      }      }
715    
# Line 851  Line 734 
734          q.add(one);          q.add(one);
735          q.add(two);          q.add(two);
736          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
737          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
738              public void run() {              public void realRun() throws InterruptedException {
739                  threadAssertFalse(q.offer(three));                  assertFalse(q.offer(three));
740                  try {                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
741                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));                  assertEquals(0, q.remainingCapacity());
742                      threadAssertEquals(0, q.remainingCapacity());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
743    
744          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
745              public void run() {              public void realRun() throws InterruptedException {
                 try {  
746                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
747                      threadAssertEquals(one, q.take());                  assertSame(one, q.take());
748                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
749    
750          joinPool(executor);          joinPool(executor);
   
751      }      }
752    
753      /**      /**
# Line 886  Line 756 
756      public void testPollInExecutor() {      public void testPollInExecutor() {
757          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
758          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
759          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
760              public void run() {              public void realRun() throws InterruptedException {
761                  threadAssertNull(q.poll());                  assertNull(q.poll());
762                  try {                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
763                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));                  assertTrue(q.isEmpty());
764                      threadAssertTrue(q.isEmpty());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
765    
766          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
767              public void run() {              public void realRun() throws InterruptedException {
                 try {  
768                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
769                      q.put(one);                      q.put(one);
770                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
771    
772          joinPool(executor);          joinPool(executor);
773      }      }
# Line 917  Line 775 
775      /**      /**
776       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
777       */       */
778      public void testSerialization() {      public void testSerialization() throws Exception {
779          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
780    
         try {  
781              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
782              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
783              out.writeObject(q);              out.writeObject(q);
# Line 932  Line 789 
789              assertEquals(q.size(), r.size());              assertEquals(q.size(), r.size());
790              while (!q.isEmpty())              while (!q.isEmpty())
791                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
         } catch (Exception e) {  
             unexpectedException();  
         }  
792      }      }
793    
794      /**      /**
# Line 945  Line 799 
799          try {          try {
800              q.drainTo(null);              q.drainTo(null);
801              shouldThrow();              shouldThrow();
802          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         }  
803      }      }
804    
805      /**      /**
# Line 957  Line 810 
810          try {          try {
811              q.drainTo(q);              q.drainTo(q);
812              shouldThrow();              shouldThrow();
813          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
814      }      }
815    
816      /**      /**
# Line 988  Line 840 
840      /**      /**
841       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
842       */       */
843      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
844          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
845          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
846                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
847                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
848                      } catch (InterruptedException ie) {              }});
849                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
850              t.start();              t.start();
851              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
852              q.drainTo(l);              q.drainTo(l);
# Line 1008  Line 855 
855                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
856              t.join();              t.join();
857              assertTrue(q.size() + l.size() >= SIZE);              assertTrue(q.size() + l.size() >= SIZE);
         } catch (Exception e) {  
             unexpectedException();  
         }  
858      }      }
859    
860      /**      /**
# Line 1021  Line 865 
865          try {          try {
866              q.drainTo(null, 0);              q.drainTo(null, 0);
867              shouldThrow();              shouldThrow();
868          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         }  
869      }      }
870    
871      /**      /**
# Line 1033  Line 876 
876          try {          try {
877              q.drainTo(q, 0);              q.drainTo(q, 0);
878              shouldThrow();              shouldThrow();
879          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
880      }      }
881    
882      /**      /**
883       * 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
884       */       */
885      public void testDrainToN() {      public void testDrainToN() {
886          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
# Line 1056  Line 898 
898          }          }
899      }      }
900    
   
901  }  }

Legend:
Removed from v.1.16  
changed lines
  Added in v.1.37

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8