[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.84, Sat May 13 22:17:12 2017 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.Collections;
15    import java.util.Iterator;
16    import java.util.NoSuchElementException;
17    import java.util.Queue;
18    import java.util.concurrent.ArrayBlockingQueue;
19    import java.util.concurrent.BlockingQueue;
20    import java.util.concurrent.CountDownLatch;
21    import java.util.concurrent.Executors;
22    import java.util.concurrent.ExecutorService;
23    import java.util.concurrent.ThreadLocalRandom;
24    
25    import junit.framework.Test;
26    
27  public class ArrayBlockingQueueTest extends JSR166TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
28    
29        public static void main(String[] args) {
30            main(suite(), args);
31        }
32    
33        public static Test suite() {
34            class Implementation implements CollectionImplementation {
35                public Class<?> klazz() { return ArrayBlockingQueue.class; }
36                public Collection emptyCollection() {
37                    boolean fair = ThreadLocalRandom.current().nextBoolean();
38                    return populatedQueue(0, SIZE, 2 * SIZE, fair);
39                }
40                public Object makeElement(int i) { return i; }
41                public boolean isConcurrent() { return true; }
42                public boolean permitsNulls() { return false; }
43            }
44    
45            return newTestSuite(
46                ArrayBlockingQueueTest.class,
47                new Fair().testSuite(),
48                new NonFair().testSuite(),
49                CollectionTest.testSuite(new Implementation()));
50        }
51    
52      public static class Fair extends BlockingQueueTest {      public static class Fair extends BlockingQueueTest {
53          protected BlockingQueue emptyCollection() {          protected BlockingQueue emptyCollection() {
54              return new ArrayBlockingQueue(20, true);              return populatedQueue(0, SIZE, 2 * SIZE, true);
55          }          }
56      }      }
57    
58      public static class NonFair extends BlockingQueueTest {      public static class NonFair extends BlockingQueueTest {
59          protected BlockingQueue emptyCollection() {          protected BlockingQueue emptyCollection() {
60              return new ArrayBlockingQueue(20, false);              return populatedQueue(0, SIZE, 2 * SIZE, false);
         }  
61      }      }
   
     public static void main(String[] args) {  
         junit.textui.TestRunner.run(suite());  
62      }      }
63    
64      public static Test suite() {      /**
65          return newTestSuite(ArrayBlockingQueueTest.class,       * Returns a new queue of given size containing consecutive
66                              new Fair().testSuite(),       * Integers 0 ... n - 1.
67                              new NonFair().testSuite());       */
68        static ArrayBlockingQueue<Integer> populatedQueue(int n) {
69            return populatedQueue(n, n, n, false);
70      }      }
71    
72      /**      /**
73       * Create a queue of given size containing consecutive       * Returns a new queue of given size containing consecutive
74       * Integers 0 ... n.       * Integers 0 ... n - 1, with given capacity range and fairness.
75       */       */
76      private ArrayBlockingQueue populatedQueue(int n) {      static ArrayBlockingQueue<Integer> populatedQueue(
77          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          int size, int minCapacity, int maxCapacity, boolean fair) {
78            ThreadLocalRandom rnd = ThreadLocalRandom.current();
79            int capacity = rnd.nextInt(minCapacity, maxCapacity + 1);
80            ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
81          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
82          for (int i = 0; i < n; i++)          // shuffle circular array elements so they wrap
83              assertTrue(q.offer(new Integer(i)));          {
84          assertFalse(q.isEmpty());              int n = rnd.nextInt(capacity);
85          assertEquals(0, q.remainingCapacity());              for (int i = 0; i < n; i++) q.add(42);
86          assertEquals(n, q.size());              for (int i = 0; i < n; i++) q.remove();
87            }
88            for (int i = 0; i < size; i++)
89                assertTrue(q.offer((Integer) i));
90            assertEquals(size == 0, q.isEmpty());
91            assertEquals(capacity - size, q.remainingCapacity());
92            assertEquals(size, q.size());
93            if (size > 0)
94                assertEquals((Integer) 0, q.peek());
95          return q;          return q;
96      }      }
97    
# Line 62  Line 105 
105      /**      /**
106       * Constructor throws IAE if capacity argument nonpositive       * Constructor throws IAE if capacity argument nonpositive
107       */       */
108      public void testConstructor2() {      public void testConstructor_nonPositiveCapacity() {
109            for (int i : new int[] { 0, -1, Integer.MIN_VALUE }) {
110          try {          try {
111              ArrayBlockingQueue q = new ArrayBlockingQueue(0);                  new ArrayBlockingQueue(i);
112              shouldThrow();              shouldThrow();
113          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
114                for (boolean fair : new boolean[] { true, false }) {
115                    try {
116                        new ArrayBlockingQueue(i, fair);
117                        shouldThrow();
118                    } catch (IllegalArgumentException success) {}
119                }
120            }
121      }      }
122    
123      /**      /**
124       * Initializing from null Collection throws NPE       * Initializing from null Collection throws NPE
125       */       */
126      public void testConstructor3() {      public void testConstructor_nullCollection() {
127          try {          try {
128              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              new ArrayBlockingQueue(1, true, null);
129              shouldThrow();              shouldThrow();
130          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
131      }      }
# Line 83  Line 134 
134       * Initializing from Collection of null elements throws NPE       * Initializing from Collection of null elements throws NPE
135       */       */
136      public void testConstructor4() {      public void testConstructor4() {
137            Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
138          try {          try {
139              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE, false, elements);
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));  
140              shouldThrow();              shouldThrow();
141          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
142      }      }
# Line 94  Line 145 
145       * Initializing from Collection with some null elements throws NPE       * Initializing from Collection with some null elements throws NPE
146       */       */
147      public void testConstructor5() {      public void testConstructor5() {
         try {  
148              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
149              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
150                  ints[i] = new Integer(i);              ints[i] = i;
151              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
152            try {
153                new ArrayBlockingQueue(SIZE, false, elements);
154              shouldThrow();              shouldThrow();
155          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
156      }      }
# Line 106  Line 158 
158      /**      /**
159       * Initializing from too large collection throws IAE       * Initializing from too large collection throws IAE
160       */       */
161      public void testConstructor6() {      public void testConstructor_collectionTooLarge() {
162            // just barely fits - succeeds
163            new ArrayBlockingQueue(SIZE, false,
164                                   Collections.nCopies(SIZE, ""));
165          try {          try {
166              Integer[] ints = new Integer[SIZE];              new ArrayBlockingQueue(SIZE - 1, false,
167              for (int i = 0; i < SIZE; ++i)                                     Collections.nCopies(SIZE, ""));
                 ints[i] = new Integer(i);  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));  
168              shouldThrow();              shouldThrow();
169          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
170      }      }
# Line 122  Line 175 
175      public void testConstructor7() {      public void testConstructor7() {
176          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
177          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
178              ints[i] = new Integer(i);              ints[i] = i;
179          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));          Collection<Integer> elements = Arrays.asList(ints);
180            ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
181          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
182              assertEquals(ints[i], q.poll());              assertEquals(ints[i], q.poll());
183      }      }
# Line 132  Line 186 
186       * Queue transitions from empty to full when elements added       * Queue transitions from empty to full when elements added
187       */       */
188      public void testEmptyFull() {      public void testEmptyFull() {
189          ArrayBlockingQueue q = new ArrayBlockingQueue(2);          BlockingQueue q = populatedQueue(0, 2, 2, false);
190          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
191          assertEquals(2, q.remainingCapacity());          assertEquals(2, q.remainingCapacity());
192          q.add(one);          q.add(one);
193          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
194          q.add(two);          assertTrue(q.offer(two));
195          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
196          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
197          assertFalse(q.offer(three));          assertFalse(q.offer(three));
# Line 147  Line 201 
201       * remainingCapacity decreases on add, increases on remove       * remainingCapacity decreases on add, increases on remove
202       */       */
203      public void testRemainingCapacity() {      public void testRemainingCapacity() {
204          ArrayBlockingQueue q = populatedQueue(SIZE);          int size = ThreadLocalRandom.current().nextInt(1, SIZE);
205          for (int i = 0; i < SIZE; ++i) {          BlockingQueue q = populatedQueue(size, size, 2 * size, false);
206              assertEquals(i, q.remainingCapacity());          int spare = q.remainingCapacity();
207              assertEquals(SIZE-i, q.size());          int capacity = spare + size;
208              q.remove();          for (int i = 0; i < size; i++) {
209          }              assertEquals(spare + i, q.remainingCapacity());
210          for (int i = 0; i < SIZE; ++i) {              assertEquals(capacity, q.size() + q.remainingCapacity());
211              assertEquals(SIZE-i, q.remainingCapacity());              assertEquals(i, q.remove());
             assertEquals(i, q.size());  
             q.add(new Integer(i));  
         }  
212      }      }
213            for (int i = 0; i < size; i++) {
214      /**              assertEquals(capacity - i, q.remainingCapacity());
215       * offer(null) throws NPE              assertEquals(capacity, q.size() + q.remainingCapacity());
216       */              assertTrue(q.add(i));
     public void testOfferNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.offer(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
217      }      }
   
     /**  
      * add(null) throws NPE  
      */  
     public void testAddNull() {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(1);  
             q.add(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
218      }      }
219    
220      /**      /**
# Line 195  Line 230 
230       * add succeeds if not full; throws ISE if full       * add succeeds if not full; throws ISE if full
231       */       */
232      public void testAdd() {      public void testAdd() {
         try {  
233              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
234              for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; i++) assertTrue(q.add((Integer) i));
                 assertTrue(q.add(new Integer(i)));  
             }  
235              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
             q.add(new Integer(SIZE));  
             shouldThrow();  
         } catch (IllegalStateException success) {}  
     }  
   
     /**  
      * addAll(null) throws NPE  
      */  
     public void testAddAll1() {  
236          try {          try {
237              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              q.add((Integer) SIZE);
             q.addAll(null);  
238              shouldThrow();              shouldThrow();
239          } catch (NullPointerException success) {}          } catch (IllegalStateException success) {}
240      }      }
241    
242      /**      /**
243       * addAll(this) throws IAE       * addAll(this) throws IAE
244       */       */
245      public void testAddAllSelf() {      public void testAddAllSelf() {
         try {  
246              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
247            try {
248              q.addAll(q);              q.addAll(q);
249              shouldThrow();              shouldThrow();
250          } catch (IllegalArgumentException success) {}          } catch (IllegalArgumentException success) {}
251      }      }
252    
   
     /**  
      * 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) {}  
     }  
   
253      /**      /**
254       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
255       * possibly adding some elements       * possibly adding some elements
256       */       */
257      public void testAddAll3() {      public void testAddAll3() {
         try {  
258              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
259              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
260              for (int i = 0; i < SIZE-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
261                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
262            try {
263              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
264              shouldThrow();              shouldThrow();
265          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
# Line 259  Line 268 
268      /**      /**
269       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
270       */       */
271      public void testAddAll4() {      public void testAddAll_insufficientSpace() {
272            int size = ThreadLocalRandom.current().nextInt(1, SIZE);
273            ArrayBlockingQueue q = populatedQueue(0, size, size, false);
274            // Just fits:
275            q.addAll(populatedQueue(size, size, 2 * size, false));
276            assertEquals(0, q.remainingCapacity());
277            assertEquals(size, q.size());
278            assertEquals(0, q.peek());
279          try {          try {
280              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              q = populatedQueue(0, size, size, false);
281              Integer[] ints = new Integer[SIZE];              q.addAll(Collections.nCopies(size + 1, 42));
             for (int i = 0; i < SIZE; ++i)  
                 ints[i] = new Integer(i);  
             q.addAll(Arrays.asList(ints));  
282              shouldThrow();              shouldThrow();
283          } catch (IllegalStateException success) {}          } catch (IllegalStateException success) {}
284      }      }
# Line 286  Line 299 
299      }      }
300    
301      /**      /**
      * put(null) throws NPE  
      */  
     public void testPutNull() throws InterruptedException {  
         try {  
             ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
             q.put(null);  
             shouldThrow();  
         } catch (NullPointerException success) {}  
      }  
   
     /**  
302       * all elements successfully put are contained       * all elements successfully put are contained
303       */       */
304      public void testPut() throws InterruptedException {      public void testPut() throws InterruptedException {
305          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
306          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
307              Integer I = new Integer(i);              Integer x = new Integer(i);
308              q.put(I);              q.put(x);
309              assertTrue(q.contains(I));              assertTrue(q.contains(x));
310          }          }
311          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
312      }      }
# Line 314  Line 316 
316       */       */
317      public void testBlockingPut() throws InterruptedException {      public void testBlockingPut() throws InterruptedException {
318          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
319          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
320            Thread t = newStartedThread(new CheckedRunnable() {
321              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
322                  for (int i = 0; i < SIZE; ++i)                  for (int i = 0; i < SIZE; ++i)
323                      q.put(i);                      q.put(i);
324                  assertEquals(SIZE, q.size());                  assertEquals(SIZE, q.size());
325                  assertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
326    
327                    Thread.currentThread().interrupt();
328                  try {                  try {
329                      q.put(99);                      q.put(99);
330                      shouldThrow();                      shouldThrow();
331                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
332                    assertFalse(Thread.interrupted());
333    
334                    pleaseInterrupt.countDown();
335                    try {
336                        q.put(99);
337                        shouldThrow();
338                    } catch (InterruptedException success) {}
339                    assertFalse(Thread.interrupted());
340              }});              }});
341    
342          t.start();          await(pleaseInterrupt);
343          Thread.sleep(SHORT_DELAY_MS);          assertThreadBlocks(t, Thread.State.WAITING);
344          t.interrupt();          t.interrupt();
345          t.join();          awaitTermination(t);
346          assertEquals(SIZE, q.size());          assertEquals(SIZE, q.size());
347          assertEquals(0, q.remainingCapacity());          assertEquals(0, q.remainingCapacity());
348      }      }
349    
350      /**      /**
351       * put blocks waiting for take when full       * put blocks interruptibly waiting for take when full
352       */       */
353      public void testPutWithTake() throws InterruptedException {      public void testPutWithTake() throws InterruptedException {
354          final int capacity = 2;          final int capacity = 2;
355          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);          final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
356          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseTake = new CountDownLatch(1);
357            final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
358            Thread t = newStartedThread(new CheckedRunnable() {
359              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
360                  for (int i = 0; i < capacity + 1; i++)                  for (int i = 0; i < capacity; i++)
361                      q.put(i);                      q.put(i);
362                    pleaseTake.countDown();
363                    q.put(86);
364    
365                    pleaseInterrupt.countDown();
366                  try {                  try {
367                      q.put(99);                      q.put(99);
368                      shouldThrow();                      shouldThrow();
369                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
370                    assertFalse(Thread.interrupted());
371              }});              }});
372    
373          t.start();          await(pleaseTake);
374          Thread.sleep(SHORT_DELAY_MS);          assertEquals(0, q.remainingCapacity());
         assertEquals(q.remainingCapacity(), 0);  
375          assertEquals(0, q.take());          assertEquals(0, q.take());
376          Thread.sleep(SHORT_DELAY_MS);  
377            await(pleaseInterrupt);
378            assertThreadBlocks(t, Thread.State.WAITING);
379          t.interrupt();          t.interrupt();
380          t.join();          awaitTermination(t);
381          assertEquals(q.remainingCapacity(), 0);          assertEquals(0, q.remainingCapacity());
382      }      }
383    
384      /**      /**
# Line 365  Line 386 
386       */       */
387      public void testTimedOffer() throws InterruptedException {      public void testTimedOffer() throws InterruptedException {
388          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
389          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
390            Thread t = newStartedThread(new CheckedRunnable() {
391              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
392                  q.put(new Object());                  q.put(new Object());
393                  q.put(new Object());                  q.put(new Object());
394                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));                  long startTime = System.nanoTime();
395                    assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
396                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
397                    pleaseInterrupt.countDown();
398                  try {                  try {
399                      q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);                      q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
400                      shouldThrow();                      shouldThrow();
401                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
402              }});              }});
403    
404          t.start();          await(pleaseInterrupt);
405          Thread.sleep(SHORT_DELAY_MS);          assertThreadBlocks(t, Thread.State.TIMED_WAITING);
406          t.interrupt();          t.interrupt();
407          t.join();          awaitTermination(t);
408      }      }
409    
410      /**      /**
# Line 397  Line 422 
422       */       */
423      public void testBlockingTake() throws InterruptedException {      public void testBlockingTake() throws InterruptedException {
424          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
425          Thread t = new Thread(new CheckedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
426            Thread t = newStartedThread(new CheckedRunnable() {
427              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
428                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
429                      assertEquals(i, q.take());  
430                  }                  Thread.currentThread().interrupt();
431                    try {
432                        q.take();
433                        shouldThrow();
434                    } catch (InterruptedException success) {}
435                    assertFalse(Thread.interrupted());
436    
437                    pleaseInterrupt.countDown();
438                  try {                  try {
439                      q.take();                      q.take();
440                      shouldThrow();                      shouldThrow();
441                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
442                    assertFalse(Thread.interrupted());
443              }});              }});
444    
445          t.start();          await(pleaseInterrupt);
446          Thread.sleep(SHORT_DELAY_MS);          assertThreadBlocks(t, Thread.State.WAITING);
447          t.interrupt();          t.interrupt();
448          t.join();          awaitTermination(t);
449      }      }
450    
   
451      /**      /**
452       * poll succeeds unless empty       * poll succeeds unless empty
453       */       */
# Line 435  Line 468 
468              assertEquals(i, q.poll(0, MILLISECONDS));              assertEquals(i, q.poll(0, MILLISECONDS));
469          }          }
470          assertNull(q.poll(0, MILLISECONDS));          assertNull(q.poll(0, MILLISECONDS));
471            checkEmpty(q);
472      }      }
473    
474      /**      /**
# Line 443  Line 477 
477      public void testTimedPoll() throws InterruptedException {      public void testTimedPoll() throws InterruptedException {
478          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
479          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
480              assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));              long startTime = System.nanoTime();
481          }              assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
482          assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
483            }
484            long startTime = System.nanoTime();
485            assertNull(q.poll(timeoutMillis(), MILLISECONDS));
486            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
487            checkEmpty(q);
488      }      }
489    
490      /**      /**
# Line 453  Line 492 
492       * returning timeout status       * returning timeout status
493       */       */
494      public void testInterruptedTimedPoll() throws InterruptedException {      public void testInterruptedTimedPoll() throws InterruptedException {
495          Thread t = new Thread(new CheckedRunnable() {          final BlockingQueue<Integer> q = populatedQueue(SIZE);
496            final CountDownLatch aboutToWait = new CountDownLatch(1);
497            Thread t = newStartedThread(new CheckedRunnable() {
498              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
499                  ArrayBlockingQueue q = populatedQueue(SIZE);                  long startTime = System.nanoTime();
500                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
501                      assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
502                  }                  }
503                    aboutToWait.countDown();
504                  try {                  try {
505                      q.poll(SMALL_DELAY_MS, MILLISECONDS);                      q.poll(LONG_DELAY_MS, MILLISECONDS);
506                      shouldThrow();                      shouldThrow();
507                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {
508                        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
509                    }
510              }});              }});
511    
512          t.start();          await(aboutToWait);
513          Thread.sleep(SHORT_DELAY_MS);          waitForThreadToEnterWaitState(t);
514          t.interrupt();          t.interrupt();
515          t.join();          awaitTermination(t);
516            checkEmpty(q);
517      }      }
518    
519      /**      /**
# Line 515  Line 560 
560      }      }
561    
562      /**      /**
      * 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());  
     }  
   
     /**  
563       * contains(x) reports true when elements added but not yet removed       * contains(x) reports true when elements added but not yet removed
564       */       */
565      public void testContains() {      public void testContains() {
566          ArrayBlockingQueue q = populatedQueue(SIZE);          int size = ThreadLocalRandom.current().nextInt(1, SIZE);
567          for (int i = 0; i < SIZE; ++i) {          ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
568            assertFalse(q.contains(null));
569            for (int i = 0; i < size; ++i) {
570              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
571              assertEquals(i, q.poll());              assertEquals(i, q.poll());
572              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
# Line 545  Line 577 
577       * clear removes all elements       * clear removes all elements
578       */       */
579      public void testClear() {      public void testClear() {
580          ArrayBlockingQueue q = populatedQueue(SIZE);          int size = ThreadLocalRandom.current().nextInt(1, 5);
581            ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
582            int capacity = size + q.remainingCapacity();
583          q.clear();          q.clear();
584          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
585          assertEquals(0, q.size());          assertEquals(0, q.size());
586          assertEquals(SIZE, q.remainingCapacity());          assertEquals(capacity, q.remainingCapacity());
587          q.add(one);          q.add(one);
588          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
589          assertTrue(q.contains(one));          assertTrue(q.contains(one));
# Line 600  Line 634 
634              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
635              assertEquals(SIZE-i, q.size());              assertEquals(SIZE-i, q.size());
636              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
637                  Integer I = (Integer)(p.remove());                  Integer x = (Integer)(p.remove());
638                  assertFalse(q.contains(I));                  assertFalse(q.contains(x));
639              }              }
640          }          }
641      }      }
642    
643      /**      void checkToArray(ArrayBlockingQueue<Integer> q) {
644       * toArray contains all elements          int size = q.size();
645       */          Object[] a1 = q.toArray();
646      public void testToArray() throws InterruptedException {          assertEquals(size, a1.length);
647          ArrayBlockingQueue q = populatedQueue(SIZE);          Integer[] a2 = q.toArray(new Integer[0]);
648          Object[] o = q.toArray();          assertEquals(size, a2.length);
649          for (int i = 0; i < o.length; i++)          Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
650              assertEquals(o[i], q.take());          assertEquals(size, a3.length);
651            Integer[] a4 = new Integer[size];
652            assertSame(a4, q.toArray(a4));
653            Integer[] a5 = new Integer[size + 1];
654            Arrays.fill(a5, 42);
655            assertSame(a5, q.toArray(a5));
656            Integer[] a6 = new Integer[size + 2];
657            Arrays.fill(a6, 42);
658            assertSame(a6, q.toArray(a6));
659            Object[][] as = { a1, a2, a3, a4, a5, a6 };
660            for (Object[] a : as) {
661                if (a.length > size) assertNull(a[size]);
662                if (a.length > size + 1) assertEquals(42, a[size + 1]);
663            }
664            Iterator it = q.iterator();
665            Integer s = q.peek();
666            for (int i = 0; i < size; i++) {
667                Integer x = (Integer) it.next();
668                assertEquals(s + i, (int) x);
669                for (Object[] a : as)
670                    assertSame(a1[i], x);
671            }
672      }      }
673    
674      /**      /**
675       * toArray(a) contains all elements       * toArray() and toArray(a) contain all elements in FIFO order
676       */       */
677      public void testToArray2() throws InterruptedException {      public void testToArray() {
678          ArrayBlockingQueue q = populatedQueue(SIZE);          final ThreadLocalRandom rnd = ThreadLocalRandom.current();
679          Integer[] ints = new Integer[SIZE];          final int size = rnd.nextInt(6);
680          ints = (Integer[])q.toArray(ints);          final int capacity = Math.max(1, size + rnd.nextInt(size + 1));
681          for (int i = 0; i < ints.length; i++)          ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
682              assertEquals(ints[i], q.take());          for (int i = 0; i < size; i++) {
683                checkToArray(q);
684                q.add(i);
685            }
686            // Provoke wraparound
687            int added = size * 2;
688            for (int i = 0; i < added; i++) {
689                checkToArray(q);
690                assertEquals((Integer) i, q.poll());
691                q.add(size + i);
692            }
693            for (int i = 0; i < size; i++) {
694                checkToArray(q);
695                assertEquals((Integer) (added + i), q.poll());
696            }
697      }      }
698    
699      /**      /**
700       * toArray(null) throws NPE       * toArray(incompatible array type) throws ArrayStoreException
701       */       */
702      public void testToArray_BadArg() {      public void testToArray_incompatibleArrayType() {
703          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
704          try {          try {
705              Object o[] = q.toArray(null);              q.toArray(new String[10]);
706              shouldThrow();              shouldThrow();
707          } catch (NullPointerException success) {}          } catch (ArrayStoreException success) {}
     }  
   
     /**  
      * toArray with incompatible array type throws CCE  
      */  
     public void testToArray1_BadArg() {  
         ArrayBlockingQueue q = populatedQueue(SIZE);  
708          try {          try {
709              Object o[] = q.toArray(new String[10]);              q.toArray(new String[0]);
710              shouldThrow();              shouldThrow();
711          } catch (ArrayStoreException success) {}          } catch (ArrayStoreException success) {}
712      }      }
713    
   
714      /**      /**
715       * iterator iterates through all elements       * iterator iterates through all elements
716       */       */
717      public void testIterator() throws InterruptedException {      public void testIterator() throws InterruptedException {
718          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
719          Iterator it = q.iterator();          Iterator it = q.iterator();
720          while (it.hasNext()) {          int i;
721            for (i = 0; it.hasNext(); i++)
722                assertTrue(q.contains(it.next()));
723            assertEquals(i, SIZE);
724            assertIteratorExhausted(it);
725    
726            it = q.iterator();
727            for (i = 0; it.hasNext(); i++)
728              assertEquals(it.next(), q.take());              assertEquals(it.next(), q.take());
729            assertEquals(i, SIZE);
730            assertIteratorExhausted(it);
731          }          }
732    
733        /**
734         * iterator of empty collection has no elements
735         */
736        public void testEmptyIterator() {
737            assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
738      }      }
739    
740      /**      /**
# Line 713  Line 789 
789          assertEquals(0, q.size());          assertEquals(0, q.size());
790      }      }
791    
   
792      /**      /**
793       * toString contains toStrings of elements       * toString contains toStrings of elements
794       */       */
# Line 721  Line 796 
796          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
797          String s = q.toString();          String s = q.toString();
798          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
799              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.contains(String.valueOf(i)));
800          }          }
801      }      }
802    
   
803      /**      /**
804       * offer transfers elements across Executor tasks       * offer transfers elements across Executor tasks
805       */       */
# Line 733  Line 807 
807          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
808          q.add(one);          q.add(one);
809          q.add(two);          q.add(two);
810          ExecutorService executor = Executors.newFixedThreadPool(2);          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
811            final ExecutorService executor = Executors.newFixedThreadPool(2);
812            try (PoolCleaner cleaner = cleaner(executor)) {
813          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
814              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
815                  assertFalse(q.offer(three));                  assertFalse(q.offer(three));
816                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));                      threadsStarted.await();
817                        assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
818                  assertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
819              }});              }});
820    
821          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
822              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
823                  Thread.sleep(SMALL_DELAY_MS);                      threadsStarted.await();
824                        assertEquals(0, q.remainingCapacity());
825                  assertSame(one, q.take());                  assertSame(one, q.take());
826              }});              }});
827            }
         joinPool(executor);  
828      }      }
829    
830      /**      /**
831       * poll retrieves elements across Executor threads       * timed poll retrieves elements across Executor threads
832       */       */
833      public void testPollInExecutor() {      public void testPollInExecutor() {
834          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
835          ExecutorService executor = Executors.newFixedThreadPool(2);          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
836            final ExecutorService executor = Executors.newFixedThreadPool(2);
837            try (PoolCleaner cleaner = cleaner(executor)) {
838          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
839              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
840                  assertNull(q.poll());                  assertNull(q.poll());
841                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));                      threadsStarted.await();
842                  assertTrue(q.isEmpty());                      assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
843                        checkEmpty(q);
844              }});              }});
845    
846          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
847              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
848                  Thread.sleep(SMALL_DELAY_MS);                      threadsStarted.await();
849                  q.put(one);                  q.put(one);
850              }});              }});
851            }
         joinPool(executor);  
852      }      }
853    
854      /**      /**
855       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
856       */       */
857      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
858          ArrayBlockingQueue q = populatedQueue(SIZE);          Queue x = populatedQueue(SIZE);
859            Queue y = serialClone(x);
860    
861          ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          assertNotSame(x, y);
862          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          assertEquals(x.size(), y.size());
863          out.writeObject(q);          assertEquals(x.toString(), y.toString());
864          out.close();          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
865            while (!x.isEmpty()) {
866          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              assertFalse(y.isEmpty());
867          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());  
868      }      }
869            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) {}  
870      }      }
871    
872      /**      /**
# Line 820  Line 876 
876          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
877          ArrayList l = new ArrayList();          ArrayList l = new ArrayList();
878          q.drainTo(l);          q.drainTo(l);
879          assertEquals(q.size(), 0);          assertEquals(0, q.size());
880          assertEquals(l.size(), SIZE);          assertEquals(SIZE, l.size());
881          for (int i = 0; i < SIZE; ++i)          for (int i = 0; i < SIZE; ++i)
882              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
883          q.add(zero);          q.add(zero);
# Line 831  Line 887 
887          assertTrue(q.contains(one));          assertTrue(q.contains(one));
888          l.clear();          l.clear();
889          q.drainTo(l);          q.drainTo(l);
890          assertEquals(q.size(), 0);          assertEquals(0, q.size());
891          assertEquals(l.size(), 2);          assertEquals(2, l.size());
892          for (int i = 0; i < 2; ++i)          for (int i = 0; i < 2; ++i)
893              assertEquals(l.get(i), new Integer(i));              assertEquals(l.get(i), new Integer(i));
894      }      }
# Line 858  Line 914 
914      }      }
915    
916      /**      /**
      * 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) {}  
     }  
   
     /**  
917       * 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
918       */       */
919      public void testDrainToN() {      public void testDrainToN() {
# Line 890  Line 924 
924              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
925              q.drainTo(l, i);              q.drainTo(l, i);
926              int k = (i < SIZE) ? i : SIZE;              int k = (i < SIZE) ? i : SIZE;
927              assertEquals(l.size(), k);              assertEquals(k, l.size());
928              assertEquals(q.size(), SIZE-k);              assertEquals(SIZE - k, q.size());
929              for (int j = 0; j < k; ++j)              for (int j = 0; j < k; ++j)
930                  assertEquals(l.get(j), new Integer(j));                  assertEquals(l.get(j), new Integer(j));
931              while (q.poll() != null) ;              do {} while (q.poll() != null);
932          }          }
933      }      }
934    
935        /**
936         * remove(null), contains(null) always return false
937         */
938        public void testNeverContainsNull() {
939            Collection<?>[] qs = {
940                populatedQueue(0, 1, 10, false),
941                populatedQueue(2, 2, 10, true),
942            };
943    
944            for (Collection<?> q : qs) {
945                assertFalse(q.contains(null));
946                assertFalse(q.remove(null));
947            }
948        }
949  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8