[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.50, Fri Jul 15 18:49:31 2011 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 41  Line 48 
48       * Create a queue of given size containing consecutive       * Create a 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 {                  try {
280                      q.put(99);                      q.put(99);
281                      shouldThrow();                      shouldThrow();
282                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
283                    assertFalse(Thread.interrupted());
284    
285                    pleaseInterrupt.countDown();
286                    try {
287                        q.put(99);
288                        shouldThrow();
289                    } 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);
         Thread.sleep(SHORT_DELAY_MS);  
325          assertEquals(q.remainingCapacity(), 0);          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(q.remainingCapacity(), 0);
333      }      }
334    
# 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 {                  try {
385                      q.take();                      q.take();
386                      shouldThrow();                      shouldThrow();
387                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
388                    assertFalse(Thread.interrupted());
389    
390                    pleaseInterrupt.countDown();
391                    try {
392                        q.take();
393                        shouldThrow();
394                    } 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 607  Line 592 
592      }      }
593    
594      /**      /**
595       * toArray contains all elements       * toArray contains all elements in FIFO order
596       */       */
597      public void testToArray() throws InterruptedException {      public void testToArray() {
598          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
599          Object[] o = q.toArray();          Object[] o = q.toArray();
600          for (int i = 0; i < o.length; i++)          for (int i = 0; i < o.length; i++)
601              assertEquals(o[i], q.take());              assertSame(o[i], q.poll());
602      }      }
603    
604      /**      /**
605       * toArray(a) contains all elements       * toArray(a) contains all elements in FIFO order
606       */       */
607      public void testToArray2() throws InterruptedException {      public void testToArray2() {
608          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue<Integer> q = populatedQueue(SIZE);
609          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
610          ints = (Integer[])q.toArray(ints);          Integer[] array = q.toArray(ints);
611            assertSame(ints, array);
612          for (int i = 0; i < ints.length; i++)          for (int i = 0; i < ints.length; i++)
613              assertEquals(ints[i], q.take());              assertSame(ints[i], q.poll());
614      }      }
615    
616      /**      /**
617       * toArray(null) throws NPE       * toArray(incompatible array type) throws ArrayStoreException
      */  
     public void testToArray_BadArg() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             Object o[] = q.toArray(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
     /**  
      * toArray with incompatible array type throws CCE  
618       */       */
619      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
620          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
621          try {          try {
622              Object o[] = q.toArray(new String[10]);              q.toArray(new String[10]);
623              shouldThrow();              shouldThrow();
624          } catch (ArrayStoreException success) {}          } catch (ArrayStoreException success) {}
625      }      }
626    
   
627      /**      /**
628       * iterator iterates through all elements       * iterator iterates through all elements
629       */       */
# Line 713  Line 687 
687          assertEquals(0, q.size());          assertEquals(0, q.size());
688      }      }
689    
   
690      /**      /**
691       * toString contains toStrings of elements       * toString contains toStrings of elements
692       */       */
# Line 721  Line 694 
694          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
695          String s = q.toString();          String s = q.toString();
696          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
697              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
698          }          }
699      }      }
700    
   
701      /**      /**
702       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
703       */       */
# Line 734  Line 706 
706          q.add(one);          q.add(one);
707          q.add(two);          q.add(two);
708          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
709            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
710          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
711              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
712                  assertFalse(q.offer(three));                  assertFalse(q.offer(three));
713                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));                  threadsStarted.await();
714                    assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
715                  assertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
716              }});              }});
717    
718          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
719              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
720                  Thread.sleep(SMALL_DELAY_MS);                  threadsStarted.await();
721                    assertEquals(0, q.remainingCapacity());
722                  assertSame(one, q.take());                  assertSame(one, q.take());
723              }});              }});
724    
# Line 751  Line 726 
726      }      }
727    
728      /**      /**
729       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
730       */       */
731      public void testPollInExecutor() {      public void testPollInExecutor() {
732          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
733            final CheckedBarrier threadsStarted = new CheckedBarrier(2);
734          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
735          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
736              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
737                  assertNull(q.poll());                  assertNull(q.poll());
738                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));                  threadsStarted.await();
739                  assertTrue(q.isEmpty());                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
740                    checkEmpty(q);
741              }});              }});
742    
743          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
744              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
745                  Thread.sleep(SMALL_DELAY_MS);                  threadsStarted.await();
746                  q.put(one);                  q.put(one);
747              }});              }});
748    
# Line 776  Line 753 
753       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
754       */       */
755      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
756          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
757            Queue y = serialClone(x);
758    
759          ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          assertTrue(x != y);
760          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          assertEquals(x.size(), y.size());
761          out.writeObject(q);          assertEquals(x.toString(), y.toString());
762          out.close();          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
763            while (!x.isEmpty()) {
764          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              assertFalse(y.isEmpty());
765          ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              assertEquals(x.remove(), y.remove());
         ArrayBlockingQueue r = (ArrayBlockingQueue)in.readObject();  
         assertEquals(q.size(), r.size());  
         while (!q.isEmpty())  
             assertEquals(q.remove(), r.remove());  
766      }      }
767            assertTrue(y.isEmpty());
     /**  
      * drainTo(null) throws NPE  
      */  
     public void testDrainToNull() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
     }  
   
     /**  
      * drainTo(this) throws IAE  
      */  
     public void testDrainToSelf() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
         try {  
             q.drainTo(q);  
             shouldThrow();  
         } catch (IllegalArgumentException success) {}  
768      }      }
769    
770      /**      /**
# Line 858  Line 812 
812      }      }
813    
814      /**      /**
      * 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) {}  
     }  
   
     /**  
815       * 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
816       */       */
817      public void testDrainToN() {      public void testDrainToN() {

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8