[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.61, Sat Jan 17 22:55:06 2015 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    
   
 import junit.framework.*;  
 import java.util.*;  
 import java.util.concurrent.*;  
9  import static java.util.concurrent.TimeUnit.MILLISECONDS;  import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  import java.io.*;  
11    import java.util.ArrayList;
12    import java.util.Arrays;
13    import java.util.Collection;
14    import java.util.Iterator;
15    import java.util.NoSuchElementException;
16    import java.util.Queue;
17    import java.util.concurrent.ArrayBlockingQueue;
18    import java.util.concurrent.BlockingQueue;
19    import java.util.concurrent.CountDownLatch;
20    import java.util.concurrent.Executors;
21    import java.util.concurrent.ExecutorService;
22    
23    import junit.framework.Test;
24    
25  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
26    
27      public static class Fair extends BlockingQueueTest {      public static class Fair extends BlockingQueueTest {
28          protected BlockingQueue emptyCollection() {          protected BlockingQueue emptyCollection() {
29              return new ArrayBlockingQueue(20, true);              return new ArrayBlockingQueue(SIZE, true);
30          }          }
31      }      }
32    
33      public static class NonFair extends BlockingQueueTest {      public static class NonFair extends BlockingQueueTest {
34          protected BlockingQueue emptyCollection() {          protected BlockingQueue emptyCollection() {
35              return new ArrayBlockingQueue(20, false);              return new ArrayBlockingQueue(SIZE, false);
36          }          }
37      }      }
38    
# Line 38  Line 47 
47      }      }
48    
49      /**      /**
50       * Create a queue of given size containing consecutive       * Returns a new queue of given size containing consecutive
51       * Integers 0 ... n.       * Integers 0 ... n.
52       */       */
53      private ArrayBlockingQueue populatedQueue(int n) {      private ArrayBlockingQueue<Integer> populatedQueue(int n) {
54          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
55          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
56          for (int i = 0; i < n; i++)          for (int i = 0; i < n; i++)
57              assertTrue(q.offer(new Integer(i)));              assertTrue(q.offer(new Integer(i)));
# Line 64  Line 73 
73       */       */
74      public void testConstructor2() {      public void testConstructor2() {
75          try {          try {
76              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              new ArrayBlockingQueue(0);
77              shouldThrow();              shouldThrow();
78          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
79      }      }
# Line 74  Line 83 
83       */       */
84      public void testConstructor3() {      public void testConstructor3() {
85          try {          try {
86              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              new ArrayBlockingQueue(1, true, null);
87              shouldThrow();              shouldThrow();
88          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
89      }      }
# Line 83  Line 92 
92       * Initializing from Collection of null elements throws NPE       * Initializing from Collection of null elements throws NPE
93       */       */
94      public void testConstructor4() {      public void testConstructor4() {
95            Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
96          try {          try {
97              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE, false, elements);
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));  
98              shouldThrow();              shouldThrow();
99          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
100      }      }
# Line 94  Line 103 
103       * Initializing from Collection with some null elements throws NPE       * Initializing from Collection with some null elements throws NPE
104       */       */
105      public void testConstructor5() {      public void testConstructor5() {
         try {  
106              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
107              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
108                  ints[i] = new Integer(i);              ints[i] = i;
109              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
110            try {
111                new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
112              shouldThrow();              shouldThrow();
113          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
114      }      }
# Line 107  Line 117 
117       * Initializing from too large collection throws IAE       * Initializing from too large collection throws IAE
118       */       */
119      public void testConstructor6() {      public void testConstructor6() {
         try {  
120              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
121              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
122                  ints[i] = new Integer(i);              ints[i] = i;
123              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
124            try {
125                new ArrayBlockingQueue(SIZE - 1, false, elements);
126              shouldThrow();              shouldThrow();
127          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
128      }      }
# Line 122  Line 133 
133      public void testConstructor7() {      public void testConstructor7() {
134          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
135          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
136              ints[i] = new Integer(i);              ints[i] = i;
137          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
138            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
139          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
140              assertEquals(ints[i], q.poll());              assertEquals(ints[i], q.poll());
141      }      }
# Line 161  Line 173 
173      }      }
174    
175      /**      /**
      * 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) {}  
     }  
   
     /**  
176       * Offer succeeds if not full; fails if full       * Offer succeeds if not full; fails if full
177       */       */
178      public void testOffer() {      public void testOffer() {
# Line 207  Line 197 
197      }      }
198    
199      /**      /**
      * addAll(null) throws NPE  
      */  
     public void testAddAll1() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.addAll(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
     /**  
200       * addAll(this) throws IAE       * addAll(this) throws IAE
201       */       */
202      public void testAddAllSelf() {      public void testAddAllSelf() {
# Line 228  Line 207 
207          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
208      }      }
209    
   
     /**  
      * 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) {}  
     }  
   
210      /**      /**
211       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
212       * possibly adding some elements       * possibly adding some elements
# Line 286  Line 252 
252      }      }
253    
254      /**      /**
      * put(null) throws NPE  
      */  
     public void testPutNull() throws InterruptedException {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
             q.put(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
      }  
   
     /**  
255       * all elements successfully put are contained       * all elements successfully put are contained
256       */       */
257      public void testPut() throws InterruptedException {      public void testPut() throws InterruptedException {
258          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
259          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
260              Integer I = new Integer(i);              Integer x = new Integer(i);
261              q.put(I);              q.put(x);
262              assertTrue(q.contains(I));              assertTrue(q.contains(x));
263          }          }
264          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
265      }      }
# Line 314  Line 269 
269       */       */
270      public void testBlockingPut() throws InterruptedException {      public void testBlockingPut() throws InterruptedException {
271          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
272          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
273            Thread t = newStartedThread(new CheckedRunnable() {
274              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
275                  for (int i = 0; i < SIZE; ++i)                  for (int i = 0; i < SIZE; ++i)
276                      q.put(i);                      q.put(i);
277                  assertEquals(SIZE, q.size());                  assertEquals(SIZE, q.size());
278                  assertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
279    
280                    Thread.currentThread().interrupt();
281                    try {
282                        q.put(99);
283                        shouldThrow();
284                    } catch (InterruptedException success) {}
285                    assertFalse(Thread.interrupted());
286    
287                    pleaseInterrupt.countDown();
288                  try {                  try {
289                      q.put(99);                      q.put(99);
290                      shouldThrow();                      shouldThrow();
291                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
292                    assertFalse(Thread.interrupted());
293              }});              }});
294    
295          t.start();          await(pleaseInterrupt);
296          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
297          t.interrupt();          t.interrupt();
298          t.join();          awaitTermination(t);
299          assertEquals(SIZE, q.size());          assertEquals(SIZE, q.size());
300          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
301      }      }
302    
303      /**      /**
304       * put blocks waiting for take when full       * put blocks interruptibly waiting for take when full
305       */       */
306      public void testPutWithTake() throws InterruptedException {      public void testPutWithTake() throws InterruptedException {
307          final int capacity = 2;          final int capacity = 2;
308          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
309          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseTake = new CountDownLatch(1);
310            final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
311            Thread t = newStartedThread(new CheckedRunnable() {
312              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
313                  for (int i = 0; i < capacity + 1; i++)                  for (int i = 0; i < capacity; i++)
314                      q.put(i);                      q.put(i);
315                    pleaseTake.countDown();
316                    q.put(86);
317    
318                    pleaseInterrupt.countDown();
319                  try {                  try {
320                      q.put(99);                      q.put(99);
321                      shouldThrow();                      shouldThrow();
322                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
323                    assertFalse(Thread.interrupted());
324              }});              }});
325    
326          t.start();          await(pleaseTake);
327          Thread.sleep(SHORT_DELAY_MS);          assertEquals(0, q.remainingCapacity());
         assertEquals(q.remainingCapacity(), 0);  
328          assertEquals(0, q.take());          assertEquals(0, q.take());
329          Thread.sleep(SHORT_DELAY_MS);  
330            await(pleaseInterrupt);
331            assertThreadStaysAlive(t);
332          t.interrupt();          t.interrupt();
333          t.join();          awaitTermination(t);
334          assertEquals(q.remainingCapacity(), 0);          assertEquals(0, q.remainingCapacity());
335      }      }
336    
337      /**      /**
# Line 365  Line 339 
339       */       */
340      public void testTimedOffer() throws InterruptedException {      public void testTimedOffer() throws InterruptedException {
341          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
342          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
343            Thread t = newStartedThread(new CheckedRunnable() {
344              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
345                  q.put(new Object());                  q.put(new Object());
346                  q.put(new Object());                  q.put(new Object());
347                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));                  long startTime = System.nanoTime();
348                    assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
349                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
350                    pleaseInterrupt.countDown();
351                  try {                  try {
352                      q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);                      q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
353                      shouldThrow();                      shouldThrow();
354                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
355              }});              }});
356    
357          t.start();          await(pleaseInterrupt);
358          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
359          t.interrupt();          t.interrupt();
360          t.join();          awaitTermination(t);
361      }      }
362    
363      /**      /**
# Line 397  Line 375 
375       */       */
376      public void testBlockingTake() throws InterruptedException {      public void testBlockingTake() throws InterruptedException {
377          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
378          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
379            Thread t = newStartedThread(new CheckedRunnable() {
380              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
381                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
382                      assertEquals(i, q.take());                      assertEquals(i, q.take());
383                  }                  }
384    
385                    Thread.currentThread().interrupt();
386                  try {                  try {
387                      q.take();                      q.take();
388                      shouldThrow();                      shouldThrow();
389                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
390                    assertFalse(Thread.interrupted());
391    
392                    pleaseInterrupt.countDown();
393                    try {
394                        q.take();
395                        shouldThrow();
396                    } catch (InterruptedException success) {}
397                    assertFalse(Thread.interrupted());
398              }});              }});
399    
400          t.start();          await(pleaseInterrupt);
401          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
402          t.interrupt();          t.interrupt();
403          t.join();          awaitTermination(t);
404      }      }
405    
   
406      /**      /**
407       * poll succeeds unless empty       * poll succeeds unless empty
408       */       */
# Line 435  Line 423 
423              assertEquals(i, q.poll(0, MILLISECONDS));              assertEquals(i, q.poll(0, MILLISECONDS));
424          }          }
425          assertNull(q.poll(0, MILLISECONDS));          assertNull(q.poll(0, MILLISECONDS));
426            checkEmpty(q);
427      }      }
428    
429      /**      /**
# Line 443  Line 432 
432      public void testTimedPoll() throws InterruptedException {      public void testTimedPoll() throws InterruptedException {
433          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
434          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
435              assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));              long startTime = System.nanoTime();
436          }              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
437          assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
438            }
439            long startTime = System.nanoTime();
440            assertNull(q.poll(timeoutMillis(), MILLISECONDS));
441            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
442            checkEmpty(q);
443      }      }
444    
445      /**      /**
# Line 453  Line 447 
447       * returning timeout status       * returning timeout status
448       */       */
449      public void testInterruptedTimedPoll() throws InterruptedException {      public void testInterruptedTimedPoll() throws InterruptedException {
450          Thread t = new Thread(new CheckedRunnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
451            final CountDownLatch aboutToWait = new CountDownLatch(1);
452            Thread t = newStartedThread(new CheckedRunnable() {
453              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
                 ArrayBlockingQueue q = populatedQueue(SIZE);  
454                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
455                      assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;                      long t0 = System.nanoTime();
456                        assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
457                        assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
458                  }                  }
459                    long t0 = System.nanoTime();
460                    aboutToWait.countDown();
461                  try {                  try {
462                      q.poll(SMALL_DELAY_MS, MILLISECONDS);                      q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
463                      shouldThrow();                      shouldThrow();
464                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {
465                        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
466                    }
467              }});              }});
468    
469          t.start();          aboutToWait.await();
470          Thread.sleep(SHORT_DELAY_MS);          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
471          t.interrupt();          t.interrupt();
472          t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
473            checkEmpty(q);
474      }      }
475    
476      /**      /**
# Line 515  Line 517 
517      }      }
518    
519      /**      /**
      * 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());  
     }  
   
     /**  
520       * contains(x) reports true when elements added but not yet removed       * contains(x) reports true when elements added but not yet removed
521       */       */
522      public void testContains() {      public void testContains() {
# Line 600  Line 587 
587              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
588              assertEquals(SIZE-i, q.size());              assertEquals(SIZE-i, q.size());
589              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
590                  Integer I = (Integer)(p.remove());                  Integer x = (Integer)(p.remove());
591                  assertFalse(q.contains(I));                  assertFalse(q.contains(x));
592              }              }
593          }          }
594      }      }
595    
596      /**      void checkToArray(ArrayBlockingQueue q) {
597       * toArray contains all elements          int size = q.size();
      */  
     public void testToArray() throws InterruptedException {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
598          Object[] o = q.toArray();          Object[] o = q.toArray();
599          for (int i = 0; i < o.length; i++)          assertEquals(size, o.length);
600              assertEquals(o[i], q.take());          Iterator it = q.iterator();
601            for (int i = 0; i < size; i++) {
602                Integer x = (Integer) it.next();
603                assertEquals((Integer)o[0] + i, (int) x);
604                assertSame(o[i], x);
605            }
606      }      }
607    
608      /**      /**
609       * toArray(a) contains all elements       * toArray() contains all elements in FIFO order
610       */       */
611      public void testToArray2() throws InterruptedException {      public void testToArray() {
612          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
613          Integer[] ints = new Integer[SIZE];          for (int i = 0; i < SIZE; i++) {
614          ints = (Integer[])q.toArray(ints);              checkToArray(q);
615          for (int i = 0; i < ints.length; i++)              q.add(i);
616              assertEquals(ints[i], q.take());          }
617            // Provoke wraparound
618            for (int i = 0; i < SIZE; i++) {
619                checkToArray(q);
620                assertEquals(i, q.poll());
621                checkToArray(q);
622                q.add(SIZE+i);
623            }
624            for (int i = 0; i < SIZE; i++) {
625                checkToArray(q);
626                assertEquals(SIZE+i, q.poll());
627            }
628        }
629    
630        void checkToArray2(ArrayBlockingQueue q) {
631            int size = q.size();
632            Integer[] a1 = size == 0 ? null : new Integer[size-1];
633            Integer[] a2 = new Integer[size];
634            Integer[] a3 = new Integer[size+2];
635            if (size > 0) Arrays.fill(a1, 42);
636            Arrays.fill(a2, 42);
637            Arrays.fill(a3, 42);
638            Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
639            Integer[] b2 = (Integer[]) q.toArray(a2);
640            Integer[] b3 = (Integer[]) q.toArray(a3);
641            assertSame(a2, b2);
642            assertSame(a3, b3);
643            Iterator it = q.iterator();
644            for (int i = 0; i < size; i++) {
645                Integer x = (Integer) it.next();
646                assertSame(b1[i], x);
647                assertEquals(b1[0] + i, (int) x);
648                assertSame(b2[i], x);
649                assertSame(b3[i], x);
650            }
651            assertNull(a3[size]);
652            assertEquals(42, (int) a3[size+1]);
653            if (size > 0) {
654                assertNotSame(a1, b1);
655                assertEquals(size, b1.length);
656                for (int i = 0; i < a1.length; i++) {
657                    assertEquals(42, (int) a1[i]);
658                }
659            }
660      }      }
661    
662      /**      /**
663       * toArray(null) throws NPE       * toArray(a) contains all elements in FIFO order
664       */       */
665      public void testToArray_BadArg() {      public void testToArray2() {
666          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
667          try {          for (int i = 0; i < SIZE; i++) {
668              Object o[] = q.toArray(null);              checkToArray2(q);
669              shouldThrow();              q.add(i);
670          } catch (NullPointerException success) {}          }
671            // Provoke wraparound
672            for (int i = 0; i < SIZE; i++) {
673                checkToArray2(q);
674                assertEquals(i, q.poll());
675                checkToArray2(q);
676                q.add(SIZE+i);
677            }
678            for (int i = 0; i < SIZE; i++) {
679                checkToArray2(q);
680                assertEquals(SIZE+i, q.poll());
681            }
682      }      }
683    
684      /**      /**
685       * toArray with incompatible array type throws CCE       * toArray(incompatible array type) throws ArrayStoreException
686       */       */
687      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
688          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
689          try {          try {
690              Object o[] = q.toArray(new String[10]);              q.toArray(new String[10]);
691              shouldThrow();              shouldThrow();
692          } catch (ArrayStoreException success) {}          } catch (ArrayStoreException success) {}
693      }      }
694    
   
695      /**      /**
696       * iterator iterates through all elements       * iterator iterates through all elements
697       */       */
698      public void testIterator() throws InterruptedException {      public void testIterator() throws InterruptedException {
699          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
700          Iterator it = q.iterator();          Iterator it = q.iterator();
701          while (it.hasNext()) {          int i;
702            for (i = 0; it.hasNext(); i++)
703                assertTrue(q.contains(it.next()));
704            assertEquals(i, SIZE);
705            assertIteratorExhausted(it);
706    
707            it = q.iterator();
708            for (i = 0; it.hasNext(); i++)
709              assertEquals(it.next(), q.take());              assertEquals(it.next(), q.take());
710            assertEquals(i, SIZE);
711            assertIteratorExhausted(it);
712          }          }
713    
714        /**
715         * iterator of empty collection has no elements
716         */
717        public void testEmptyIterator() {
718            assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
719      }      }
720    
721      /**      /**
# Line 713  Line 770 
770          assertEquals(0, q.size());          assertEquals(0, q.size());
771      }      }
772    
   
773      /**      /**
774       * toString contains toStrings of elements       * toString contains toStrings of elements
775       */       */
# Line 721  Line 777 
777          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
778          String s = q.toString();          String s = q.toString();
779          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
780              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
781          }          }
782      }      }
783    
   
784      /**      /**
785       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
786       */       */
# Line 734  Line 789 
789          q.add(one);          q.add(one);
790          q.add(two);          q.add(two);
791          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
792            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
793          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
794              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
795                  assertFalse(q.offer(three));                  assertFalse(q.offer(three));
796                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));                  threadsStarted.await();
797                    assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
798                  assertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
799              }});              }});
800    
801          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
802              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
803                  Thread.sleep(SMALL_DELAY_MS);                  threadsStarted.await();
804                    assertEquals(0, q.remainingCapacity());
805                  assertSame(one, q.take());                  assertSame(one, q.take());
806              }});              }});
807    
# Line 751  Line 809 
809      }      }
810    
811      /**      /**
812       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
813       */       */
814      public void testPollInExecutor() {      public void testPollInExecutor() {
815          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
816            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
817          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
818          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
819              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
820                  assertNull(q.poll());                  assertNull(q.poll());
821                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));                  threadsStarted.await();
822                  assertTrue(q.isEmpty());                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
823                    checkEmpty(q);
824              }});              }});
825    
826          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
827              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
828                  Thread.sleep(SMALL_DELAY_MS);                  threadsStarted.await();
829                  q.put(one);                  q.put(one);
830              }});              }});
831    
# Line 776  Line 836 
836       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
837       */       */
838      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
839          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
840            Queue y = serialClone(x);
         ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);  
         ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));  
         out.writeObject(q);  
         out.close();  
841    
842          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());          assertNotSame(x, y);
843          ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));          assertEquals(x.size(), y.size());
844          ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();          assertEquals(x.toString(), y.toString());
845          assertEquals(q.size(), r.size());          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
846          while (!q.isEmpty())          while (!x.isEmpty()) {
847              assertEquals(q.remove(), r.remove());              assertFalse(y.isEmpty());
848      }              assertEquals(x.remove(), y.remove());
   
     /**  
      * drainTo(null) throws NPE  
      */  
     public void testDrainToNull() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
849      }      }
850            assertTrue(y.isEmpty());
     /**  
      * drainTo(this) throws IAE  
      */  
     public void testDrainToSelf() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(q);  
             shouldThrow();  
         } catch (IllegalArgumentException success) {}  
851      }      }
852    
853      /**      /**
# Line 820  Line 857 
857          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
858          ArrayList l = new ArrayList();          ArrayList l = new ArrayList();
859          q.drainTo(l);          q.drainTo(l);
860          assertEquals(q.size(), 0);          assertEquals(0, q.size());
861          assertEquals(l.size(), SIZE);          assertEquals(SIZE, l.size());
862          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
863              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
864          q.add(zero);          q.add(zero);
# Line 831  Line 868 
868          assertTrue(q.contains(one));          assertTrue(q.contains(one));
869          l.clear();          l.clear();
870          q.drainTo(l);          q.drainTo(l);
871          assertEquals(q.size(), 0);          assertEquals(0, q.size());
872          assertEquals(l.size(), 2);          assertEquals(2, l.size());
873          for (int i = 0; i < 2; ++i)          for (int i = 0; i < 2; ++i)
874              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
875      }      }
# Line 858  Line 895 
895      }      }
896    
897      /**      /**
      * 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) {}  
     }  
   
     /**  
898       * 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
899       */       */
900      public void testDrainToN() {      public void testDrainToN() {
# Line 890  Line 905 
905              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
906              q.drainTo(l, i);              q.drainTo(l, i);
907              int k = (i < SIZE) ? i : SIZE;              int k = (i < SIZE) ? i : SIZE;
908              assertEquals(l.size(), k);              assertEquals(k, l.size());
909              assertEquals(q.size(), SIZE-k);              assertEquals(SIZE-k, q.size());
910              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
911                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
912              while (q.poll() != null) ;              do {} while (q.poll() != null);
913          }          }
914      }      }
915    
916        /**
917         * remove(null), contains(null) always return false
918         */
919        public void testNeverContainsNull() {
920            Collection<?>[] qs = {
921                new ArrayBlockingQueue<Object>(10),
922                populatedQueue(2),
923            };
924    
925            for (Collection<?> q : qs) {
926                assertFalse(q.contains(null));
927                assertFalse(q.remove(null));
928            }
929        }
930  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8