[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.46, Sat May 21 06:24:33 2011 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/publicdomain/zero/1.0/
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9    
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 {
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      /**      /**
41       * Create a queue of given size containing consecutive       * Create a queue of given size containing consecutive
42       * Integers 0 ... n.       * Integers 0 ... n.
43       */       */
44      private ArrayBlockingQueue populatedQueue(int n) {      private ArrayBlockingQueue<Integer> populatedQueue(int n) {
45          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
46          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
47          for(int i = 0; i < n; i++)          for(int i = 0; i < n; i++)
48              assertTrue(q.offer(new Integer(i)));              assertTrue(q.offer(new Integer(i)));
# Line 48  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 59  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 71  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 85  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 99  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 115  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 192  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 204  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 216  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 230  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 245  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 259  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 277  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 309  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          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
317                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
318                      int added = 0;              public void realRun() throws InterruptedException {
319                    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                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);                      q.put(99);
325                          for (int i = 0; i < SIZE; ++i) {                      shouldThrow();
326                              q.put(new Integer(i));                  } catch (InterruptedException success) {}
                             ++added;  
                         }  
                         q.put(new Integer(SIZE));  
                         threadShouldThrow();  
                     } catch (InterruptedException ie){  
                         threadAssertEquals(added, SIZE);  
                     }  
327                  }});                  }});
328          try {  
329              t.start();              t.start();
330             Thread.sleep(SHORT_DELAY_MS);          delay(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);          delay(SHORT_DELAY_MS);
355              q.take();          assertEquals(q.remainingCapacity(), 0);
356            assertEquals(0, q.take());
357            delay(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() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
369                  public void run() {          Thread t = newStartedThread(new CheckedRunnable() {
370                      try {              public void realRun() throws InterruptedException {
371                          q.put(new Object());                          q.put(new Object());
372                          q.put(new Object());                          q.put(new Object());
373                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                  long startTime = System.nanoTime();
374                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
375                          threadShouldThrow();                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
376                    pleaseInterrupt.countDown();
377                    try {
378                        q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
379                        shouldThrow();
380                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
381                  }              }});
             });  
382    
383          try {          await(pleaseInterrupt);
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
384              t.interrupt();              t.interrupt();
385              t.join();          awaitTermination(t);
         } catch (Exception e){  
             unexpectedException();  
         }  
386      }      }
387    
388      /**      /**
389       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
390       */       */
391      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
392              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
393              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
394                  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();  
395          }          }
396      }      }
397    
398      /**      /**
399       * Take removes existing elements until empty, then blocks interruptibly       * Take removes existing elements until empty, then blocks interruptibly
400       */       */
401      public void testBlockingTake() {      public void testBlockingTake() throws InterruptedException {
402          Thread t = new Thread(new Runnable() {          final ArrayBlockingQueue q = populatedQueue(SIZE);
403                  public void run() {          Thread t = new Thread(new CheckedRunnable() {
404                      try {              public void realRun() throws InterruptedException {
                         ArrayBlockingQueue q = populatedQueue(SIZE);  
405                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
406                              threadAssertEquals(i, ((Integer)q.take()).intValue());                      assertEquals(i, q.take());
407                          }                          }
408                    try {
409                          q.take();                          q.take();
410                          threadShouldThrow();                      shouldThrow();
411                      } catch (InterruptedException success){                  } catch (InterruptedException success) {}
                     }  
412                  }});                  }});
413          try {  
414              t.start();              t.start();
415              Thread.sleep(SHORT_DELAY_MS);          delay(SHORT_DELAY_MS);
416              t.interrupt();              t.interrupt();
417              t.join();              t.join();
418          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
419    
420    
421      /**      /**
# Line 476  Line 424 
424      public void testPoll() {      public void testPoll() {
425          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
426          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
427              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
428          }          }
429          assertNull(q.poll());          assertNull(q.poll());
430      }      }
431    
432      /**      /**
433       * timed pool with zero timeout succeeds when non-empty, else times out       * timed poll with zero timeout succeeds when non-empty, else times out
434       */       */
435      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
436              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
437              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
438                  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();  
439          }          }
440            assertNull(q.poll(0, MILLISECONDS));
441      }      }
442    
443      /**      /**
444       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed poll with nonzero timeout succeeds when non-empty, else times out
445       */       */
446      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
447              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
448              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
449                  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();  
450          }          }
451            assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
452      }      }
453    
454      /**      /**
455       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
456       * returning timeout status       * returning timeout status
457       */       */
458      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
459          Thread t = new Thread(new Runnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
460                  public void run() {          final CountDownLatch aboutToWait = new CountDownLatch(1);
461                      try {          Thread t = newStartedThread(new CheckedRunnable() {
462                          ArrayBlockingQueue q = populatedQueue(SIZE);              public void realRun() throws InterruptedException {
463                          for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
464                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                      long t0 = System.nanoTime();
465                        assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
466                        assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
467                          }                          }
468                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                  long t0 = System.nanoTime();
469                    aboutToWait.countDown();
470                    try {
471                        q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
472                        shouldThrow();
473                      } catch (InterruptedException success){                      } catch (InterruptedException success){
474                        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
475                      }                      }
476                  }});                  }});
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             t.interrupt();  
             t.join();  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
477    
478      /**          aboutToWait.await();
479       *  timed poll before a delayed offer fails; after offer succeeds;          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
      *  on interruption throws  
      */  
     public void testTimedPollWithOffer() {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);  
                         q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);  
                         threadShouldThrow();  
                     } catch (InterruptedException success) { }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SMALL_DELAY_MS);  
             assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));  
480              t.interrupt();              t.interrupt();
481              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
482          } catch (Exception e){          checkEmpty(q);
             unexpectedException();  
483          }          }
     }  
   
484    
485      /**      /**
486       * peek returns next element, or null if empty       * peek returns next element, or null if empty
# Line 572  Line 488 
488      public void testPeek() {      public void testPeek() {
489          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
490          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
491              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
492              q.poll();              assertEquals(i, q.poll());
493              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
494                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
495          }          }
496          assertNull(q.peek());          assertNull(q.peek());
497      }      }
# Line 586  Line 502 
502      public void testElement() {      public void testElement() {
503          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
504          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
505              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
506              q.poll();              assertEquals(i, q.poll());
507          }          }
508          try {          try {
509              q.element();              q.element();
510              shouldThrow();              shouldThrow();
511          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
512      }      }
513    
514      /**      /**
# Line 602  Line 517 
517      public void testRemove() {      public void testRemove() {
518          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
519          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
520              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
521          }          }
522          try {          try {
523              q.remove();              q.remove();
524              shouldThrow();              shouldThrow();
525          } catch (NoSuchElementException success){          } catch (NoSuchElementException success) {}
         }  
526      }      }
527    
528      /**      /**
# Line 633  Line 547 
547          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
548          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
549              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
550              q.poll();              assertEquals(i, q.poll());
551              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
552          }          }
553      }      }
# Line 649  Line 563 
563          assertEquals(SIZE, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
564          q.add(one);          q.add(one);
565          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
566            assertTrue(q.contains(one));
567          q.clear();          q.clear();
568          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
569      }      }
# Line 703  Line 618 
618      }      }
619    
620      /**      /**
621       *  toArray contains all elements       * toArray contains all elements in FIFO order
622       */       */
623      public void testToArray() {      public void testToArray() {
624          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
625          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
626          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
627              assertEquals(o[i], q.take());              assertSame(o[i], q.poll());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
628      }      }
629    
630      /**      /**
631       * toArray(a) contains all elements       * toArray(a) contains all elements in FIFO order
632       */       */
633      public void testToArray2() {      public void testToArray2() {
634          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue<Integer> q = populatedQueue(SIZE);
635          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
636          ints = (Integer[])q.toArray(ints);          Integer[] array = q.toArray(ints);
637          try {          assertSame(ints, array);
638              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
639                  assertEquals(ints[i], q.take());              assertSame(ints[i], q.poll());
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
640      }      }
641    
642      /**      /**
643       * toArray(null) throws NPE       * toArray(null) throws NullPointerException
644       */       */
645      public void testToArray_BadArg() {      public void testToArray_NullArg() {
         try {  
646              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
647              Object o[] = q.toArray(null);          try {
648                q.toArray(null);
649              shouldThrow();              shouldThrow();
650          } catch(NullPointerException success){}          } catch(NullPointerException success){}
651      }      }
652    
653      /**      /**
654       * toArray with incompatable array type throws CCE       * toArray(incompatible array type) throws ArrayStoreException
655       */       */
656      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
657              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
658              Object o[] = q.toArray(new String[10] );          try {
659                q.toArray(new String[10]);
660              shouldThrow();              shouldThrow();
661          } catch(ArrayStoreException  success){}          } catch(ArrayStoreException  success){}
662      }      }
# Line 757  Line 665 
665      /**      /**
666       * iterator iterates through all elements       * iterator iterates through all elements
667       */       */
668      public void testIterator() {      public void testIterator() throws InterruptedException {
669          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
670          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
671              while(it.hasNext()){              while(it.hasNext()){
672                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
673              }              }
         } catch (InterruptedException e){  
             unexpectedException();  
         }  
674      }      }
675    
676      /**      /**
# Line 783  Line 687 
687          it.remove();          it.remove();
688    
689          it = q.iterator();          it = q.iterator();
690          assertEquals(it.next(), one);          assertSame(it.next(), one);
691          assertEquals(it.next(), three);          assertSame(it.next(), three);
692          assertFalse(it.hasNext());          assertFalse(it.hasNext());
693      }      }
694    
# Line 801  Line 705 
705    
706          int k = 0;          int k = 0;
707          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
708              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
709          }          }
710          assertEquals(3, k);          assertEquals(3, k);
711      }      }
# Line 815  Line 718 
718          q.add(one);          q.add(one);
719          q.add(two);          q.add(two);
720          q.add(three);          q.add(three);
         try {  
721              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
722                  q.remove();                  q.remove();
723                  it.next();                  it.next();
724              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
725          assertEquals(0, q.size());          assertEquals(0, q.size());
726      }      }
727    
# Line 848  Line 746 
746          q.add(one);          q.add(one);
747          q.add(two);          q.add(two);
748          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
749          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
750              public void run() {              public void realRun() throws InterruptedException {
751                  threadAssertFalse(q.offer(three));                  assertFalse(q.offer(three));
752                  try {                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
753                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertEquals(0, q.remainingCapacity());
754                      threadAssertEquals(0, q.remainingCapacity());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
755    
756          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
757              public void run() {              public void realRun() throws InterruptedException {
758                  try {                  delay(SMALL_DELAY_MS);
759                      Thread.sleep(SMALL_DELAY_MS);                  assertSame(one, q.take());
760                      threadAssertEquals(one, q.take());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
761    
762          joinPool(executor);          joinPool(executor);
   
763      }      }
764    
765      /**      /**
# Line 883  Line 768 
768      public void testPollInExecutor() {      public void testPollInExecutor() {
769          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
770          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
771          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
772              public void run() {              public void realRun() throws InterruptedException {
773                  threadAssertNull(q.poll());                  assertNull(q.poll());
774                  try {                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
775                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));                  assertTrue(q.isEmpty());
776                      threadAssertTrue(q.isEmpty());              }});
                 }  
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
777    
778          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
779              public void run() {              public void realRun() throws InterruptedException {
780                  try {                  delay(SMALL_DELAY_MS);
                     Thread.sleep(SMALL_DELAY_MS);  
781                      q.put(one);                      q.put(one);
782                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
783    
784          joinPool(executor);          joinPool(executor);
785      }      }
# Line 914  Line 787 
787      /**      /**
788       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
789       */       */
790      public void testSerialization() {      public void testSerialization() throws Exception {
791          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
792    
         try {  
793              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
794              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
795              out.writeObject(q);              out.writeObject(q);
# Line 929  Line 801 
801              assertEquals(q.size(), r.size());              assertEquals(q.size(), r.size());
802              while (!q.isEmpty())              while (!q.isEmpty())
803                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
         } catch(Exception e){  
             unexpectedException();  
         }  
804      }      }
805    
806      /**      /**
# Line 942  Line 811 
811          try {          try {
812              q.drainTo(null);              q.drainTo(null);
813              shouldThrow();              shouldThrow();
814          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
815      }      }
816    
817      /**      /**
# Line 954  Line 822 
822          try {          try {
823              q.drainTo(q);              q.drainTo(q);
824              shouldThrow();              shouldThrow();
825          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
826      }      }
827    
828      /**      /**
# Line 969  Line 836 
836          assertEquals(l.size(), SIZE);          assertEquals(l.size(), SIZE);
837          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
838              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
839            q.add(zero);
840            q.add(one);
841            assertFalse(q.isEmpty());
842            assertTrue(q.contains(zero));
843            assertTrue(q.contains(one));
844            l.clear();
845            q.drainTo(l);
846            assertEquals(q.size(), 0);
847            assertEquals(l.size(), 2);
848            for (int i = 0; i < 2; ++i)
849                assertEquals(l.get(i), new Integer(i));
850      }      }
851    
852      /**      /**
853       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
854       */       */
855      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
856          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
857          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
858                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
859                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
860                      } catch (InterruptedException ie){              }});
861                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
862              t.start();              t.start();
863              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
864              q.drainTo(l);              q.drainTo(l);
# Line 993  Line 866 
866              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
867                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
868              t.join();              t.join();
869              assertTrue(q.size() + l.size() == SIZE+1);          assertTrue(q.size() + l.size() >= SIZE);
         } catch(Exception e){  
             unexpectedException();  
         }  
870      }      }
871    
872      /**      /**
# Line 1007  Line 877 
877          try {          try {
878              q.drainTo(null, 0);              q.drainTo(null, 0);
879              shouldThrow();              shouldThrow();
880          } catch(NullPointerException success) {          } catch (NullPointerException success) {}
         }  
881      }      }
882    
883      /**      /**
# Line 1019  Line 888 
888          try {          try {
889              q.drainTo(q, 0);              q.drainTo(q, 0);
890              shouldThrow();              shouldThrow();
891          } catch(IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
892      }      }
893    
894      /**      /**
895       * 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
896       */       */
897      public void testDrainToN() {      public void testDrainToN() {
898            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
899          for (int i = 0; i < SIZE + 2; ++i) {          for (int i = 0; i < SIZE + 2; ++i) {
900              ArrayBlockingQueue q = populatedQueue(SIZE);              for (int j = 0; j < SIZE; j++)
901                    assertTrue(q.offer(new Integer(j)));
902              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
903              q.drainTo(l, i);              q.drainTo(l, i);
904              int k = (i < SIZE)? i : SIZE;              int k = (i < SIZE)? i : SIZE;
             assertEquals(q.size(), SIZE-k);  
905              assertEquals(l.size(), k);              assertEquals(l.size(), k);
906                assertEquals(q.size(), SIZE-k);
907              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
908                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
909                while (q.poll() != null) ;
910          }          }
911      }      }
912    
   
913  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8