[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.37, Thu Oct 28 22:20:47 2010 UTC revision 1.55, Wed Feb 20 12:07:45 2013 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain   * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.   * Pat Fisher, Mike Judd.
7   */   */
8    
   
9  import junit.framework.*;  import junit.framework.*;
10  import java.util.*;  import java.util.Arrays;
11  import java.util.concurrent.*;  import java.util.ArrayList;
12    import java.util.Collection;
13    import java.util.Iterator;
14    import java.util.NoSuchElementException;
15    import java.util.Queue;
16    import java.util.concurrent.ArrayBlockingQueue;
17    import java.util.concurrent.BlockingQueue;
18    import java.util.concurrent.CountDownLatch;
19    import java.util.concurrent.Executors;
20    import java.util.concurrent.ExecutorService;
21  import static java.util.concurrent.TimeUnit.MILLISECONDS;  import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import java.io.*;  
22    
23  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
24    
25      public static class Fair extends BlockingQueueTest {      public static class Fair extends BlockingQueueTest {
26          protected BlockingQueue emptyCollection() {          protected BlockingQueue emptyCollection() {
27              return new ArrayBlockingQueue(20, true);              return new ArrayBlockingQueue(SIZE, true);
28          }          }
29      }      }
30    
31      public static class NonFair extends BlockingQueueTest {      public static class NonFair extends BlockingQueueTest {
32          protected BlockingQueue emptyCollection() {          protected BlockingQueue emptyCollection() {
33              return new ArrayBlockingQueue(20, false);              return new ArrayBlockingQueue(SIZE, false);
34          }          }
35      }      }
36    
# Line 38  Line 45 
45      }      }
46    
47      /**      /**
48       * Create a queue of given size containing consecutive       * Returns a new queue of given size containing consecutive
49       * Integers 0 ... n.       * Integers 0 ... n.
50       */       */
51      private ArrayBlockingQueue populatedQueue(int n) {      private ArrayBlockingQueue<Integer> populatedQueue(int n) {
52          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
53          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
54          for (int i = 0; i < n; i++)          for (int i = 0; i < n; i++)
55              assertTrue(q.offer(new Integer(i)));              assertTrue(q.offer(new Integer(i)));
# Line 64  Line 71 
71       */       */
72      public void testConstructor2() {      public void testConstructor2() {
73          try {          try {
74              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              new ArrayBlockingQueue(0);
75              shouldThrow();              shouldThrow();
76          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
77      }      }
# Line 74  Line 81 
81       */       */
82      public void testConstructor3() {      public void testConstructor3() {
83          try {          try {
84              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              new ArrayBlockingQueue(1, true, null);
85              shouldThrow();              shouldThrow();
86          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
87      }      }
# Line 83  Line 90 
90       * Initializing from Collection of null elements throws NPE       * Initializing from Collection of null elements throws NPE
91       */       */
92      public void testConstructor4() {      public void testConstructor4() {
93            Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
94          try {          try {
95              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE, false, elements);
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));  
96              shouldThrow();              shouldThrow();
97          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
98      }      }
# Line 94  Line 101 
101       * Initializing from Collection with some null elements throws NPE       * Initializing from Collection with some null elements throws NPE
102       */       */
103      public void testConstructor5() {      public void testConstructor5() {
         try {  
104              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
105              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
106                  ints[i] = new Integer(i);              ints[i] = i;
107              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
108            try {
109                new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
110              shouldThrow();              shouldThrow();
111          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
112      }      }
# Line 107  Line 115 
115       * Initializing from too large collection throws IAE       * Initializing from too large collection throws IAE
116       */       */
117      public void testConstructor6() {      public void testConstructor6() {
         try {  
118              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
119              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
120                  ints[i] = new Integer(i);              ints[i] = i;
121              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
122            try {
123                new ArrayBlockingQueue(SIZE - 1, false, elements);
124              shouldThrow();              shouldThrow();
125          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
126      }      }
# Line 122  Line 131 
131      public void testConstructor7() {      public void testConstructor7() {
132          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
133          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
134              ints[i] = new Integer(i);              ints[i] = i;
135          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
136            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
137          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
138              assertEquals(ints[i], q.poll());              assertEquals(ints[i], q.poll());
139      }      }
# Line 161  Line 171 
171      }      }
172    
173      /**      /**
      * offer(null) throws NPE  
      */  
     public void testOfferNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.offer(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
     /**  
      * add(null) throws NPE  
      */  
     public void testAddNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.add(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
     /**  
174       * Offer succeeds if not full; fails if full       * Offer succeeds if not full; fails if full
175       */       */
176      public void testOffer() {      public void testOffer() {
# Line 207  Line 195 
195      }      }
196    
197      /**      /**
      * addAll(null) throws NPE  
      */  
     public void testAddAll1() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.addAll(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
     /**  
198       * addAll(this) throws IAE       * addAll(this) throws IAE
199       */       */
200      public void testAddAllSelf() {      public void testAddAllSelf() {
# Line 228  Line 205 
205          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
206      }      }
207    
   
     /**  
      * addAll of a collection with null elements throws NPE  
      */  
     public void testAddAll2() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
             Integer[] ints = new Integer[SIZE];  
             q.addAll(Arrays.asList(ints));  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
208      /**      /**
209       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
210       * possibly adding some elements       * possibly adding some elements
# Line 286  Line 250 
250      }      }
251    
252      /**      /**
      * put(null) throws NPE  
      */  
     public void testPutNull() throws InterruptedException {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
             q.put(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
      }  
   
     /**  
253       * all elements successfully put are contained       * all elements successfully put are contained
254       */       */
255      public void testPut() throws InterruptedException {      public void testPut() throws InterruptedException {
# Line 314  Line 267 
267       */       */
268      public void testBlockingPut() throws InterruptedException {      public void testBlockingPut() throws InterruptedException {
269          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
270          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
271            Thread t = newStartedThread(new CheckedRunnable() {
272              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
273                  for (int i = 0; i < SIZE; ++i)                  for (int i = 0; i < SIZE; ++i)
274                      q.put(i);                      q.put(i);
275                  assertEquals(SIZE, q.size());                  assertEquals(SIZE, q.size());
276                  assertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
277    
278                    Thread.currentThread().interrupt();
279                    try {
280                        q.put(99);
281                        shouldThrow();
282                    } catch (InterruptedException success) {}
283                    assertFalse(Thread.interrupted());
284    
285                    pleaseInterrupt.countDown();
286                  try {                  try {
287                      q.put(99);                      q.put(99);
288                      shouldThrow();                      shouldThrow();
289                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
290                    assertFalse(Thread.interrupted());
291              }});              }});
292    
293          t.start();          await(pleaseInterrupt);
294          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
295          t.interrupt();          t.interrupt();
296          t.join();          awaitTermination(t);
297          assertEquals(SIZE, q.size());          assertEquals(SIZE, q.size());
298          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
299      }      }
300    
301      /**      /**
302       * put blocks waiting for take when full       * put blocks interruptibly waiting for take when full
303       */       */
304      public void testPutWithTake() throws InterruptedException {      public void testPutWithTake() throws InterruptedException {
305          final int capacity = 2;          final int capacity = 2;
306          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
307          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseTake = new CountDownLatch(1);
308            final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
309            Thread t = newStartedThread(new CheckedRunnable() {
310              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
311                  for (int i = 0; i < capacity + 1; i++)                  for (int i = 0; i < capacity; i++)
312                      q.put(i);                      q.put(i);
313                    pleaseTake.countDown();
314                    q.put(86);
315    
316                    pleaseInterrupt.countDown();
317                  try {                  try {
318                      q.put(99);                      q.put(99);
319                      shouldThrow();                      shouldThrow();
320                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
321                    assertFalse(Thread.interrupted());
322              }});              }});
323    
324          t.start();          await(pleaseTake);
325          Thread.sleep(SHORT_DELAY_MS);          assertEquals(0, q.remainingCapacity());
         assertEquals(q.remainingCapacity(), 0);  
326          assertEquals(0, q.take());          assertEquals(0, q.take());
327          Thread.sleep(SHORT_DELAY_MS);  
328            await(pleaseInterrupt);
329            assertThreadStaysAlive(t);
330          t.interrupt();          t.interrupt();
331          t.join();          awaitTermination(t);
332          assertEquals(q.remainingCapacity(), 0);          assertEquals(0, q.remainingCapacity());
333      }      }
334    
335      /**      /**
# Line 365  Line 337 
337       */       */
338      public void testTimedOffer() throws InterruptedException {      public void testTimedOffer() throws InterruptedException {
339          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
340          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
341            Thread t = newStartedThread(new CheckedRunnable() {
342              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
343                  q.put(new Object());                  q.put(new Object());
344                  q.put(new Object());                  q.put(new Object());
345                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));                  long startTime = System.nanoTime();
346                    assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
347                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
348                    pleaseInterrupt.countDown();
349                  try {                  try {
350                      q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);                      q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
351                      shouldThrow();                      shouldThrow();
352                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
353              }});              }});
354    
355          t.start();          await(pleaseInterrupt);
356          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
357          t.interrupt();          t.interrupt();
358          t.join();          awaitTermination(t);
359      }      }
360    
361      /**      /**
# Line 397  Line 373 
373       */       */
374      public void testBlockingTake() throws InterruptedException {      public void testBlockingTake() throws InterruptedException {
375          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
376          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
377            Thread t = newStartedThread(new CheckedRunnable() {
378              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
379                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
380                      assertEquals(i, q.take());                      assertEquals(i, q.take());
381                  }                  }
382    
383                    Thread.currentThread().interrupt();
384                    try {
385                        q.take();
386                        shouldThrow();
387                    } catch (InterruptedException success) {}
388                    assertFalse(Thread.interrupted());
389    
390                    pleaseInterrupt.countDown();
391                  try {                  try {
392                      q.take();                      q.take();
393                      shouldThrow();                      shouldThrow();
394                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
395                    assertFalse(Thread.interrupted());
396              }});              }});
397    
398          t.start();          await(pleaseInterrupt);
399          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
400          t.interrupt();          t.interrupt();
401          t.join();          awaitTermination(t);
402      }      }
403    
   
404      /**      /**
405       * poll succeeds unless empty       * poll succeeds unless empty
406       */       */
# Line 435  Line 421 
421              assertEquals(i, q.poll(0, MILLISECONDS));              assertEquals(i, q.poll(0, MILLISECONDS));
422          }          }
423          assertNull(q.poll(0, MILLISECONDS));          assertNull(q.poll(0, MILLISECONDS));
424            checkEmpty(q);
425      }      }
426    
427      /**      /**
# Line 443  Line 430 
430      public void testTimedPoll() throws InterruptedException {      public void testTimedPoll() throws InterruptedException {
431          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
432          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
433              assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));              long startTime = System.nanoTime();
434          }              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
435          assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
436            }
437            long startTime = System.nanoTime();
438            assertNull(q.poll(timeoutMillis(), MILLISECONDS));
439            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
440            checkEmpty(q);
441      }      }
442    
443      /**      /**
# Line 453  Line 445 
445       * returning timeout status       * returning timeout status
446       */       */
447      public void testInterruptedTimedPoll() throws InterruptedException {      public void testInterruptedTimedPoll() throws InterruptedException {
448          Thread t = new Thread(new CheckedRunnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
449            final CountDownLatch aboutToWait = new CountDownLatch(1);
450            Thread t = newStartedThread(new CheckedRunnable() {
451              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
                 ArrayBlockingQueue q = populatedQueue(SIZE);  
452                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
453                      assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;                      long t0 = System.nanoTime();
454                        assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
455                        assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
456                  }                  }
457                    long t0 = System.nanoTime();
458                    aboutToWait.countDown();
459                  try {                  try {
460                      q.poll(SMALL_DELAY_MS, MILLISECONDS);                      q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
461                      shouldThrow();                      shouldThrow();
462                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {
463                        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
464                    }
465              }});              }});
466    
467          t.start();          aboutToWait.await();
468          Thread.sleep(SHORT_DELAY_MS);          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
469          t.interrupt();          t.interrupt();
470          t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
471            checkEmpty(q);
472      }      }
473    
474      /**      /**
# Line 515  Line 515 
515      }      }
516    
517      /**      /**
      * remove(x) removes x and returns true if present  
      */  
     public void testRemoveElement() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         for (int i = 1; i < SIZE; i+=2) {  
             assertTrue(q.remove(new Integer(i)));  
         }  
         for (int i = 0; i < SIZE; i+=2) {  
             assertTrue(q.remove(new Integer(i)));  
             assertFalse(q.remove(new Integer(i+1)));  
         }  
         assertTrue(q.isEmpty());  
     }  
   
     /**  
518       * contains(x) reports true when elements added but not yet removed       * contains(x) reports true when elements added but not yet removed
519       */       */
520      public void testContains() {      public void testContains() {
# Line 606  Line 591 
591          }          }
592      }      }
593    
594      /**      void checkToArray(ArrayBlockingQueue q) {
595       * toArray contains all elements          int size = q.size();
      */  
     public void testToArray() throws InterruptedException {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
596          Object[] o = q.toArray();          Object[] o = q.toArray();
597          for (int i = 0; i < o.length; i++)          assertEquals(size, o.length);
598              assertEquals(o[i], q.take());          Iterator it = q.iterator();
599            for (int i = 0; i < size; i++) {
600                Integer x = (Integer) it.next();
601                assertEquals((Integer)o[0] + i, (int) x);
602                assertSame(o[i], x);
603            }
604      }      }
605    
606      /**      /**
607       * toArray(a) contains all elements       * toArray() contains all elements in FIFO order
608       */       */
609      public void testToArray2() throws InterruptedException {      public void testToArray() {
610          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
611          Integer[] ints = new Integer[SIZE];          for (int i = 0; i < SIZE; i++) {
612          ints = (Integer[])q.toArray(ints);              checkToArray(q);
613          for (int i = 0; i < ints.length; i++)              q.add(i);
614              assertEquals(ints[i], q.take());          }
615            // Provoke wraparound
616            for (int i = 0; i < SIZE; i++) {
617                checkToArray(q);
618                assertEquals(i, q.poll());
619                checkToArray(q);
620                q.add(SIZE+i);
621            }
622            for (int i = 0; i < SIZE; i++) {
623                checkToArray(q);
624                assertEquals(SIZE+i, q.poll());
625            }
626        }
627    
628        void checkToArray2(ArrayBlockingQueue q) {
629            int size = q.size();
630            Integer[] a1 = size == 0 ? null : new Integer[size-1];
631            Integer[] a2 = new Integer[size];
632            Integer[] a3 = new Integer[size+2];
633            if (size > 0) Arrays.fill(a1, 42);
634            Arrays.fill(a2, 42);
635            Arrays.fill(a3, 42);
636            Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
637            Integer[] b2 = (Integer[]) q.toArray(a2);
638            Integer[] b3 = (Integer[]) q.toArray(a3);
639            assertSame(a2, b2);
640            assertSame(a3, b3);
641            Iterator it = q.iterator();
642            for (int i = 0; i < size; i++) {
643                Integer x = (Integer) it.next();
644                assertSame(b1[i], x);
645                assertEquals(b1[0] + i, (int) x);
646                assertSame(b2[i], x);
647                assertSame(b3[i], x);
648            }
649            assertNull(a3[size]);
650            assertEquals(42, (int) a3[size+1]);
651            if (size > 0) {
652                assertNotSame(a1, b1);
653                assertEquals(size, b1.length);
654                for (int i = 0; i < a1.length; i++) {
655                    assertEquals(42, (int) a1[i]);
656                }
657            }
658      }      }
659    
660      /**      /**
661       * toArray(null) throws NPE       * toArray(a) contains all elements in FIFO order
662       */       */
663      public void testToArray_BadArg() {      public void testToArray2() {
664          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
665          try {          for (int i = 0; i < SIZE; i++) {
666              Object o[] = q.toArray(null);              checkToArray2(q);
667              shouldThrow();              q.add(i);
668          } catch (NullPointerException success) {}          }
669            // Provoke wraparound
670            for (int i = 0; i < SIZE; i++) {
671                checkToArray2(q);
672                assertEquals(i, q.poll());
673                checkToArray2(q);
674                q.add(SIZE+i);
675            }
676            for (int i = 0; i < SIZE; i++) {
677                checkToArray2(q);
678                assertEquals(SIZE+i, q.poll());
679            }
680      }      }
681    
682      /**      /**
683       * toArray with incompatible array type throws CCE       * toArray(incompatible array type) throws ArrayStoreException
684       */       */
685      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
686          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
687          try {          try {
688              Object o[] = q.toArray(new String[10]);              q.toArray(new String[10]);
689              shouldThrow();              shouldThrow();
690          } catch (ArrayStoreException success) {}          } catch (ArrayStoreException success) {}
691      }      }
692    
   
693      /**      /**
694       * iterator iterates through all elements       * iterator iterates through all elements
695       */       */
# Line 713  Line 753 
753          assertEquals(0, q.size());          assertEquals(0, q.size());
754      }      }
755    
   
756      /**      /**
757       * toString contains toStrings of elements       * toString contains toStrings of elements
758       */       */
# Line 721  Line 760 
760          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
761          String s = q.toString();          String s = q.toString();
762          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
763              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
764          }          }
765      }      }
766    
   
767      /**      /**
768       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
769       */       */
# Line 734  Line 772 
772          q.add(one);          q.add(one);
773          q.add(two);          q.add(two);
774          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
775            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
776          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
777              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
778                  assertFalse(q.offer(three));                  assertFalse(q.offer(three));
779                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));                  threadsStarted.await();
780                    assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
781                  assertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
782              }});              }});
783    
784          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
785              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
786                  Thread.sleep(SMALL_DELAY_MS);                  threadsStarted.await();
787                    assertEquals(0, q.remainingCapacity());
788                  assertSame(one, q.take());                  assertSame(one, q.take());
789              }});              }});
790    
# Line 751  Line 792 
792      }      }
793    
794      /**      /**
795       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
796       */       */
797      public void testPollInExecutor() {      public void testPollInExecutor() {
798          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
799            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
800          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
801          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
802              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
803                  assertNull(q.poll());                  assertNull(q.poll());
804                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));                  threadsStarted.await();
805                  assertTrue(q.isEmpty());                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
806                    checkEmpty(q);
807              }});              }});
808    
809          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
810              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
811                  Thread.sleep(SMALL_DELAY_MS);                  threadsStarted.await();
812                  q.put(one);                  q.put(one);
813              }});              }});
814    
# Line 776  Line 819 
819       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
820       */       */
821      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
822          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
823            Queue y = serialClone(x);
         ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);  
         ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));  
         out.writeObject(q);  
         out.close();  
824    
825          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());          assertTrue(x != y);
826          ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));          assertEquals(x.size(), y.size());
827          ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();          assertEquals(x.toString(), y.toString());
828          assertEquals(q.size(), r.size());          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
829          while (!q.isEmpty())          while (!x.isEmpty()) {
830              assertEquals(q.remove(), r.remove());              assertFalse(y.isEmpty());
831      }              assertEquals(x.remove(), y.remove());
   
     /**  
      * drainTo(null) throws NPE  
      */  
     public void testDrainToNull() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
832      }      }
833            assertTrue(y.isEmpty());
     /**  
      * drainTo(this) throws IAE  
      */  
     public void testDrainToSelf() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(q);  
             shouldThrow();  
         } catch (IllegalArgumentException success) {}  
834      }      }
835    
836      /**      /**
# Line 820  Line 840 
840          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
841          ArrayList l = new ArrayList();          ArrayList l = new ArrayList();
842          q.drainTo(l);          q.drainTo(l);
843          assertEquals(q.size(), 0);          assertEquals(0, q.size());
844          assertEquals(l.size(), SIZE);          assertEquals(SIZE, l.size());
845          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
846              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
847          q.add(zero);          q.add(zero);
# Line 831  Line 851 
851          assertTrue(q.contains(one));          assertTrue(q.contains(one));
852          l.clear();          l.clear();
853          q.drainTo(l);          q.drainTo(l);
854          assertEquals(q.size(), 0);          assertEquals(0, q.size());
855          assertEquals(l.size(), 2);          assertEquals(2, l.size());
856          for (int i = 0; i < 2; ++i)          for (int i = 0; i < 2; ++i)
857              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
858      }      }
# Line 858  Line 878 
878      }      }
879    
880      /**      /**
      * drainTo(null, n) throws NPE  
      */  
     public void testDrainToNullN() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(null, 0);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
     /**  
      * drainTo(this, n) throws IAE  
      */  
     public void testDrainToSelfN() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(q, 0);  
             shouldThrow();  
         } catch (IllegalArgumentException success) {}  
     }  
   
     /**  
881       * drainTo(c, n) empties first min(n, size) elements of queue into c       * drainTo(c, n) empties first min(n, size) elements of queue into c
882       */       */
883      public void testDrainToN() {      public void testDrainToN() {
# Line 890  Line 888 
888              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
889              q.drainTo(l, i);              q.drainTo(l, i);
890              int k = (i < SIZE) ? i : SIZE;              int k = (i < SIZE) ? i : SIZE;
891              assertEquals(l.size(), k);              assertEquals(k, l.size());
892              assertEquals(q.size(), SIZE-k);              assertEquals(SIZE-k, q.size());
893              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
894                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
895              while (q.poll() != null) ;              while (q.poll() != null) ;

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8