[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.22, Sat Nov 21 19:48:24 2009 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                public void realRun() {
300                      int added = 0;                      int added = 0;
301                      try {                      try {
                         ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
302                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
303                              q.put(new Integer(i));                              q.put(new Integer(i));
304                              ++added;                              ++added;
305                          }                          }
306                          q.put(new Integer(SIZE));                          q.put(new Integer(SIZE));
307                          threadShouldThrow();                          threadShouldThrow();
308                      } catch (InterruptedException ie){                  } catch (InterruptedException success) {
309                          threadAssertEquals(added, SIZE);                          threadAssertEquals(added, SIZE);
310                      }                  }}});
311                  }});  
         try {  
312              t.start();              t.start();
313             Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(MEDIUM_DELAY_MS);
314             t.interrupt();             t.interrupt();
315             t.join();             t.join();
316          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
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 ArrayBlockingQueue q = new ArrayBlockingQueue(2);
323          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
324                  public void run() {              public void realRun() {
325                      int added = 0;                      int added = 0;
326                      try {                      try {
327                          q.put(new Object());                          q.put(new Object());
# Line 362  Line 333 
333                          q.put(new Object());                          q.put(new Object());
334                          ++added;                          ++added;
335                          threadShouldThrow();                          threadShouldThrow();
336                      } catch (InterruptedException e){                  } catch (InterruptedException success) {
337                          threadAssertTrue(added >= 2);                          threadAssertTrue(added >= 2);
338                      }                      }
339                  }              }});
340              });  
         try {  
341              t.start();              t.start();
342              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
343              q.take();              q.take();
344              t.interrupt();              t.interrupt();
345              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
346      }      }
347    
348      /**      /**
349       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
350       */       */
351      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
352          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
353          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
354                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
355                          q.put(new Object());                          q.put(new Object());
356                          q.put(new Object());                          q.put(new Object());
357                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
358                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
359                          threadShouldThrow();              }};
                     } catch (InterruptedException success){}  
                 }  
             });  
360    
         try {  
361              t.start();              t.start();
362              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
363              t.interrupt();              t.interrupt();
364              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
365      }      }
366    
367      /**      /**
368       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
369       */       */
370      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
371              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
372              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
373                  assertEquals(i, ((Integer)q.take()).intValue());                  assertEquals(i, ((Integer)q.take()).intValue());
374              }              }
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
375      }      }
376    
377      /**      /**
378       * take blocks interruptibly when empty       * take blocks interruptibly when empty
379       */       */
380      public void testTakeFromEmpty() {      public void testTakeFromEmpty() throws InterruptedException {
381          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
382          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
383                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
384                          q.take();                          q.take();
385                          threadShouldThrow();              }};
386                      } catch (InterruptedException success){ }  
                 }  
             });  
         try {  
387              t.start();              t.start();
388              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
389              t.interrupt();              t.interrupt();
390              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
391      }      }
392    
393      /**      /**
394       * Take removes existing elements until empty, then blocks interruptibly       * Take removes existing elements until empty, then blocks interruptibly
395       */       */
396      public void testBlockingTake() {      public void testBlockingTake() throws InterruptedException {
397          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
398                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
399                          ArrayBlockingQueue q = populatedQueue(SIZE);                          ArrayBlockingQueue q = populatedQueue(SIZE);
400                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
401                              threadAssertEquals(i, ((Integer)q.take()).intValue());                              threadAssertEquals(i, ((Integer)q.take()).intValue());
402                          }                          }
403                          q.take();                          q.take();
404                          threadShouldThrow();              }};
405                      } catch (InterruptedException success){  
                     }  
                 }});  
         try {  
406              t.start();              t.start();
407              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
408              t.interrupt();              t.interrupt();
409              t.join();              t.join();
410          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
411    
412    
413      /**      /**
# Line 484  Line 424 
424      /**      /**
425       * timed pool with zero timeout succeeds when non-empty, else times out       * timed pool with zero timeout succeeds when non-empty, else times out
426       */       */
427      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
428              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
429              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
430                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());              assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
             }  
             assertNull(q.poll(0, TimeUnit.MILLISECONDS));  
         } catch (InterruptedException e){  
             unexpectedException();  
431          }          }
432            assertNull(q.poll(0, MILLISECONDS));
433      }      }
434    
435      /**      /**
436       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed pool with nonzero timeout succeeds when non-empty, else times out
437       */       */
438      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
439              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
440              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
441                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());              assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
             }  
             assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
         } catch (InterruptedException e){  
             unexpectedException();  
442          }          }
443            assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
444      }      }
445    
446      /**      /**
447       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
448       * returning timeout status       * returning timeout status
449       */       */
450      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
451          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
452                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
453                          ArrayBlockingQueue q = populatedQueue(SIZE);                          ArrayBlockingQueue q = populatedQueue(SIZE);
454                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
455                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
                         }  
                         threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
                     } catch (InterruptedException success){  
456                      }                      }
                 }});  
457          try {          try {
458                        q.poll(SMALL_DELAY_MS, MILLISECONDS);
459                        shouldThrow();
460                    } catch (InterruptedException success) {}
461                }});
462    
463              t.start();              t.start();
464              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
465              t.interrupt();              t.interrupt();
466              t.join();              t.join();
467          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
468    
469      /**      /**
470       *  timed poll before a delayed offer fails; after offer succeeds;       *  timed poll before a delayed offer fails; after offer succeeds;
471       *  on interruption throws       *  on interruption throws
472       */       */
473      public void testTimedPollWithOffer() {      public void testTimedPollWithOffer() throws InterruptedException {
474          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
475          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
476                  public void run() {              public void realRun() throws InterruptedException {
477                      try {                  threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
478                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                  q.poll(LONG_DELAY_MS, MILLISECONDS);
479                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  q.poll(LONG_DELAY_MS, MILLISECONDS);
480                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);              }};
481                          threadShouldThrow();  
                     } catch (InterruptedException success) { }  
                 }  
             });  
         try {  
482              t.start();              t.start();
483              Thread.sleep(SMALL_DELAY_MS);              Thread.sleep(SMALL_DELAY_MS);
484              assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
485              t.interrupt();              t.interrupt();
486              t.join();              t.join();
         } catch (Exception e){  
             unexpectedException();  
         }  
487      }      }
488    
489    
# Line 592  Line 513 
513          try {          try {
514              q.element();              q.element();
515              shouldThrow();              shouldThrow();
516          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
517      }      }
518    
519      /**      /**
# Line 607  Line 527 
527          try {          try {
528              q.remove();              q.remove();
529              shouldThrow();              shouldThrow();
530          } catch (NoSuchElementException success){          } catch (NoSuchElementException success) {}
         }  
531      }      }
532    
533      /**      /**
# Line 649  Line 568 
568          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
569          q.add(one);          q.add(one);
570          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
571            assertTrue(q.contains(one));
572          q.clear();          q.clear();
573          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
574      }      }
# Line 705  Line 625 
625      /**      /**
626       *  toArray contains all elements       *  toArray contains all elements
627       */       */
628      public void testToArray() {      public void testToArray() throws InterruptedException {
629          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
630          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
631          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
632              assertEquals(o[i], q.take());              assertEquals(o[i], q.take());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
633      }      }
634    
635      /**      /**
636       * toArray(a) contains all elements       * toArray(a) contains all elements
637       */       */
638      public void testToArray2() {      public void testToArray2() throws InterruptedException {
639          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
640          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
641          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
         try {  
642              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
643                  assertEquals(ints[i], q.take());                  assertEquals(ints[i], q.take());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
644      }      }
645    
646      /**      /**
# Line 743  Line 655 
655      }      }
656    
657      /**      /**
658       * toArray with incompatable array type throws CCE       * toArray with incompatible array type throws CCE
659       */       */
660      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
661          try {          try {
# Line 757  Line 669 
669      /**      /**
670       * iterator iterates through all elements       * iterator iterates through all elements
671       */       */
672      public void testIterator() {      public void testIterator() throws InterruptedException {
673          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
674          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
675              while(it.hasNext()){              while(it.hasNext()){
676                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
677              }              }
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
678      }      }
679    
680      /**      /**
# Line 815  Line 723 
723          q.add(one);          q.add(one);
724          q.add(two);          q.add(two);
725          q.add(three);          q.add(three);
         try {  
726              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
727                  q.remove();                  q.remove();
728                  it.next();                  it.next();
729              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
730          assertEquals(0, q.size());          assertEquals(0, q.size());
731      }      }
732    
# Line 848  Line 751 
751          q.add(one);          q.add(one);
752          q.add(two);          q.add(two);
753          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
754          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
755              public void run() {              public void realRun() throws InterruptedException {
756                  threadAssertFalse(q.offer(three));                  threadAssertFalse(q.offer(three));
757                  try {                  threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
                     threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));  
758                      threadAssertEquals(0, q.remainingCapacity());                      threadAssertEquals(0, q.remainingCapacity());
759                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
760    
761          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
762              public void run() {              public void realRun() throws InterruptedException {
                 try {  
763                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
764                      threadAssertEquals(one, q.take());                      threadAssertEquals(one, q.take());
765                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
766    
767          joinPool(executor);          joinPool(executor);
768    
# Line 883  Line 774 
774      public void testPollInExecutor() {      public void testPollInExecutor() {
775          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
776          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
777          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
778              public void run() {              public void realRun() throws InterruptedException {
779                  threadAssertNull(q.poll());                  threadAssertNull(q.poll());
780                  try {                  threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
                     threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));  
781                      threadAssertTrue(q.isEmpty());                      threadAssertTrue(q.isEmpty());
782                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
783    
784          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
785              public void run() {              public void realRun() throws InterruptedException {
                 try {  
786                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
787                      q.put(one);                      q.put(one);
788                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
789    
790          joinPool(executor);          joinPool(executor);
791      }      }
# Line 914  Line 793 
793      /**      /**
794       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
795       */       */
796      public void testSerialization() {      public void testSerialization() throws Exception {
797          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
798    
         try {  
799              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
800              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
801              out.writeObject(q);              out.writeObject(q);
# Line 929  Line 807 
807              assertEquals(q.size(), r.size());              assertEquals(q.size(), r.size());
808              while (!q.isEmpty())              while (!q.isEmpty())
809                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
         } catch(Exception e){  
             unexpectedException();  
         }  
810      }      }
811    
812      /**      /**
# Line 942  Line 817 
817          try {          try {
818              q.drainTo(null);              q.drainTo(null);
819              shouldThrow();              shouldThrow();
820          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
821      }      }
822    
823      /**      /**
# Line 954  Line 828 
828          try {          try {
829              q.drainTo(q);              q.drainTo(q);
830              shouldThrow();              shouldThrow();
831          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
832      }      }
833    
834      /**      /**
# Line 969  Line 842 
842          assertEquals(l.size(), SIZE);          assertEquals(l.size(), SIZE);
843          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
844              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
845            q.add(zero);
846            q.add(one);
847            assertFalse(q.isEmpty());
848            assertTrue(q.contains(zero));
849            assertTrue(q.contains(one));
850            l.clear();
851            q.drainTo(l);
852            assertEquals(q.size(), 0);
853            assertEquals(l.size(), 2);
854            for (int i = 0; i < 2; ++i)
855                assertEquals(l.get(i), new Integer(i));
856      }      }
857    
858      /**      /**
859       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
860       */       */
861      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
862          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
863          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
864                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
865                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
866                      } catch (InterruptedException ie){              }});
867                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
868              t.start();              t.start();
869              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
870              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 872 
872              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
873                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
874              t.join();              t.join();
875              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
876      }      }
877    
878      /**      /**
# Line 1007  Line 883 
883          try {          try {
884              q.drainTo(null, 0);              q.drainTo(null, 0);
885              shouldThrow();              shouldThrow();
886          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
887      }      }
888    
889      /**      /**
# Line 1019  Line 894 
894          try {          try {
895              q.drainTo(q, 0);              q.drainTo(q, 0);
896              shouldThrow();              shouldThrow();
897          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
898      }      }
899    
900      /**      /**
901       * 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
902       */       */
903      public void testDrainToN() {      public void testDrainToN() {
904            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
905          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
906              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
907                    assertTrue(q.offer(new Integer(j)));
908              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
909              q.drainTo(l, i);              q.drainTo(l, i);
910              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
             assertEquals(q.size(), SIZE-k);  
911              assertEquals(l.size(), k);              assertEquals(l.size(), k);
912                assertEquals(q.size(), SIZE-k);
913              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
914                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
915                while (q.poll() != null) ;
916          }          }
917      }      }
918    
   
919  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8