[cvs] / jsr166 / src / test / tck / ArrayBlockingQueueTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/ArrayBlockingQueueTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.92 - (view) (download)

1 : dl 1.1 /*
2 : dl 1.7 * Written by Doug Lea with assistance from members of JCP JSR-166
3 :     * Expert Group and released to the public domain, as explained at
4 : jsr166 1.43 * http://creativecommons.org/publicdomain/zero/1.0/
5 : jsr166 1.12 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 :     * Pat Fisher, Mike Judd.
7 : dl 1.1 */
8 :    
9 : jsr166 1.58 import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 :    
11 :     import java.util.ArrayList;
12 : jsr166 1.48 import java.util.Arrays;
13 :     import java.util.Collection;
14 : jsr166 1.77 import java.util.Collections;
15 : jsr166 1.48 import java.util.Iterator;
16 :     import java.util.NoSuchElementException;
17 : jsr166 1.49 import java.util.Queue;
18 : jsr166 1.48 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 : jsr166 1.74 import java.util.concurrent.ThreadLocalRandom;
24 : jsr166 1.58
25 :     import junit.framework.Test;
26 : dl 1.1
27 : dl 1.3 public class ArrayBlockingQueueTest extends JSR166TestCase {
28 : jsr166 1.32
29 : dl 1.1 public static void main(String[] args) {
30 : jsr166 1.65 main(suite(), args);
31 : dl 1.1 }
32 : jsr166 1.32
33 : dl 1.1 public static Test suite() {
34 : jsr166 1.73 class Implementation implements CollectionImplementation {
35 :     public Class<?> klazz() { return ArrayBlockingQueue.class; }
36 : jsr166 1.75 public Collection emptyCollection() {
37 :     boolean fair = ThreadLocalRandom.current().nextBoolean();
38 :     return populatedQueue(0, SIZE, 2 * SIZE, fair);
39 :     }
40 : jsr166 1.73 public Object makeElement(int i) { return i; }
41 :     public boolean isConcurrent() { return true; }
42 :     public boolean permitsNulls() { return false; }
43 :     }
44 : jsr166 1.76
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 {
53 :     protected BlockingQueue emptyCollection() {
54 :     return populatedQueue(0, SIZE, 2 * SIZE, true);
55 :     }
56 :     }
57 :    
58 :     public static class NonFair extends BlockingQueueTest {
59 :     protected BlockingQueue emptyCollection() {
60 :     return populatedQueue(0, SIZE, 2 * SIZE, false);
61 :     }
62 : dl 1.1 }
63 :    
64 :     /**
65 : jsr166 1.54 * Returns a new queue of given size containing consecutive
66 : jsr166 1.72 * Integers 0 ... n - 1.
67 : dl 1.1 */
68 : jsr166 1.75 static ArrayBlockingQueue<Integer> populatedQueue(int n) {
69 :     return populatedQueue(n, n, n, false);
70 :     }
71 :    
72 :     /**
73 :     * Returns a new queue of given size containing consecutive
74 :     * Integers 0 ... n - 1, with given capacity range and fairness.
75 :     */
76 :     static ArrayBlockingQueue<Integer> populatedQueue(
77 :     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 : dl 1.1 assertTrue(q.isEmpty());
82 : jsr166 1.75 // shuffle circular array elements so they wrap
83 :     {
84 :     int n = rnd.nextInt(capacity);
85 :     for (int i = 0; i < n; i++) q.add(42);
86 :     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 : dl 1.1 return q;
96 :     }
97 : jsr166 1.12
98 : dl 1.4 /**
99 : dl 1.5 * A new queue has the indicated capacity
100 : dl 1.4 */
101 :     public void testConstructor1() {
102 : dl 1.3 assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
103 : dl 1.1 }
104 :    
105 : dl 1.4 /**
106 : jsr166 1.91 * Constructor throws IllegalArgumentException if capacity argument nonpositive
107 : dl 1.4 */
108 : jsr166 1.77 public void testConstructor_nonPositiveCapacity() {
109 :     for (int i : new int[] { 0, -1, Integer.MIN_VALUE }) {
110 :     try {
111 :     new ArrayBlockingQueue(i);
112 :     shouldThrow();
113 :     } 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 : dl 1.1 }
122 :    
123 : dl 1.4 /**
124 : dl 1.5 * Initializing from null Collection throws NPE
125 : dl 1.4 */
126 : jsr166 1.77 public void testConstructor_nullCollection() {
127 : dl 1.1 try {
128 : jsr166 1.48 new ArrayBlockingQueue(1, true, null);
129 : dl 1.4 shouldThrow();
130 : jsr166 1.17 } catch (NullPointerException success) {}
131 : dl 1.1 }
132 :    
133 : dl 1.4 /**
134 : dl 1.5 * Initializing from Collection of null elements throws NPE
135 : dl 1.4 */
136 :     public void testConstructor4() {
137 : jsr166 1.48 Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
138 : dl 1.1 try {
139 : jsr166 1.48 new ArrayBlockingQueue(SIZE, false, elements);
140 : dl 1.4 shouldThrow();
141 : jsr166 1.17 } catch (NullPointerException success) {}
142 : dl 1.1 }
143 :    
144 : dl 1.4 /**
145 : dl 1.5 * Initializing from Collection with some null elements throws NPE
146 : dl 1.4 */
147 :     public void testConstructor5() {
148 : jsr166 1.48 Integer[] ints = new Integer[SIZE];
149 : jsr166 1.66 for (int i = 0; i < SIZE - 1; ++i)
150 : jsr166 1.48 ints[i] = i;
151 :     Collection<Integer> elements = Arrays.asList(ints);
152 : dl 1.1 try {
153 : jsr166 1.62 new ArrayBlockingQueue(SIZE, false, elements);
154 : dl 1.4 shouldThrow();
155 : jsr166 1.17 } catch (NullPointerException success) {}
156 : dl 1.1 }
157 :    
158 : dl 1.4 /**
159 : jsr166 1.91 * Initializing from too large collection throws IllegalArgumentException
160 : dl 1.4 */
161 : jsr166 1.77 public void testConstructor_collectionTooLarge() {
162 :     // just barely fits - succeeds
163 :     new ArrayBlockingQueue(SIZE, false,
164 :     Collections.nCopies(SIZE, ""));
165 : dl 1.1 try {
166 : jsr166 1.77 new ArrayBlockingQueue(SIZE - 1, false,
167 :     Collections.nCopies(SIZE, ""));
168 : dl 1.4 shouldThrow();
169 : jsr166 1.17 } catch (IllegalArgumentException success) {}
170 : dl 1.1 }
171 :    
172 : dl 1.4 /**
173 : dl 1.5 * Queue contains all elements of collection used to initialize
174 : dl 1.4 */
175 :     public void testConstructor7() {
176 : jsr166 1.19 Integer[] ints = new Integer[SIZE];
177 :     for (int i = 0; i < SIZE; ++i)
178 : jsr166 1.48 ints[i] = i;
179 :     Collection<Integer> elements = Arrays.asList(ints);
180 :     ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
181 : jsr166 1.19 for (int i = 0; i < SIZE; ++i)
182 :     assertEquals(ints[i], q.poll());
183 : dl 1.1 }
184 :    
185 : dl 1.4 /**
186 : dl 1.5 * Queue transitions from empty to full when elements added
187 : dl 1.4 */
188 : dl 1.1 public void testEmptyFull() {
189 : jsr166 1.77 BlockingQueue q = populatedQueue(0, 2, 2, false);
190 : dl 1.1 assertTrue(q.isEmpty());
191 : dl 1.4 assertEquals(2, q.remainingCapacity());
192 : dl 1.3 q.add(one);
193 : dl 1.1 assertFalse(q.isEmpty());
194 : jsr166 1.77 assertTrue(q.offer(two));
195 : dl 1.1 assertFalse(q.isEmpty());
196 : dl 1.4 assertEquals(0, q.remainingCapacity());
197 :     assertFalse(q.offer(three));
198 : dl 1.1 }
199 :    
200 : dl 1.4 /**
201 : dl 1.5 * remainingCapacity decreases on add, increases on remove
202 : dl 1.4 */
203 :     public void testRemainingCapacity() {
204 : jsr166 1.77 int size = ThreadLocalRandom.current().nextInt(1, SIZE);
205 :     BlockingQueue q = populatedQueue(size, size, 2 * size, false);
206 :     int spare = q.remainingCapacity();
207 :     int capacity = spare + size;
208 :     for (int i = 0; i < size; i++) {
209 :     assertEquals(spare + i, q.remainingCapacity());
210 :     assertEquals(capacity, q.size() + q.remainingCapacity());
211 : jsr166 1.64 assertEquals(i, q.remove());
212 : dl 1.1 }
213 : jsr166 1.77 for (int i = 0; i < size; i++) {
214 :     assertEquals(capacity - i, q.remainingCapacity());
215 :     assertEquals(capacity, q.size() + q.remainingCapacity());
216 : jsr166 1.64 assertTrue(q.add(i));
217 : dl 1.1 }
218 :     }
219 :    
220 : dl 1.4 /**
221 : dl 1.5 * Offer succeeds if not full; fails if full
222 : dl 1.4 */
223 :     public void testOffer() {
224 : dl 1.1 ArrayBlockingQueue q = new ArrayBlockingQueue(1);
225 : dl 1.3 assertTrue(q.offer(zero));
226 :     assertFalse(q.offer(one));
227 : dl 1.1 }
228 :    
229 : dl 1.4 /**
230 : jsr166 1.91 * add succeeds if not full; throws IllegalStateException if full
231 : dl 1.4 */
232 :     public void testAdd() {
233 : jsr166 1.63 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
234 : jsr166 1.78 for (int i = 0; i < SIZE; i++) assertTrue(q.add((Integer) i));
235 : jsr166 1.63 assertEquals(0, q.remainingCapacity());
236 : jsr166 1.15 try {
237 : jsr166 1.78 q.add((Integer) SIZE);
238 : jsr166 1.17 shouldThrow();
239 :     } catch (IllegalStateException success) {}
240 : dl 1.1 }
241 :    
242 : dl 1.4 /**
243 : jsr166 1.91 * addAll(this) throws IllegalArgumentException
244 : dl 1.6 */
245 :     public void testAddAllSelf() {
246 : jsr166 1.63 ArrayBlockingQueue q = populatedQueue(SIZE);
247 : dl 1.6 try {
248 :     q.addAll(q);
249 :     shouldThrow();
250 : jsr166 1.17 } catch (IllegalArgumentException success) {}
251 : dl 1.6 }
252 :    
253 : dl 1.4 /**
254 : dl 1.5 * addAll of a collection with any null elements throws NPE after
255 :     * possibly adding some elements
256 : dl 1.4 */
257 :     public void testAddAll3() {
258 : jsr166 1.63 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
259 :     Integer[] ints = new Integer[SIZE];
260 : jsr166 1.66 for (int i = 0; i < SIZE - 1; ++i)
261 : jsr166 1.63 ints[i] = new Integer(i);
262 : dl 1.1 try {
263 :     q.addAll(Arrays.asList(ints));
264 : dl 1.4 shouldThrow();
265 : jsr166 1.17 } catch (NullPointerException success) {}
266 : dl 1.1 }
267 : jsr166 1.30
268 : dl 1.4 /**
269 : jsr166 1.91 * addAll throws IllegalStateException if not enough room
270 : dl 1.4 */
271 : jsr166 1.78 public void testAddAll_insufficientSpace() {
272 : jsr166 1.80 int size = ThreadLocalRandom.current().nextInt(1, SIZE);
273 : jsr166 1.78 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 : dl 1.1 try {
280 : jsr166 1.78 q = populatedQueue(0, size, size, false);
281 :     q.addAll(Collections.nCopies(size + 1, 42));
282 : dl 1.4 shouldThrow();
283 : jsr166 1.17 } catch (IllegalStateException success) {}
284 : dl 1.1 }
285 : jsr166 1.30
286 : dl 1.4 /**
287 : dl 1.5 * Queue contains all elements, in traversal order, of successful addAll
288 : dl 1.4 */
289 :     public void testAddAll5() {
290 : jsr166 1.17 Integer[] empty = new Integer[0];
291 :     Integer[] ints = new Integer[SIZE];
292 :     for (int i = 0; i < SIZE; ++i)
293 :     ints[i] = new Integer(i);
294 :     ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
295 :     assertFalse(q.addAll(Arrays.asList(empty)));
296 :     assertTrue(q.addAll(Arrays.asList(ints)));
297 :     for (int i = 0; i < SIZE; ++i)
298 :     assertEquals(ints[i], q.poll());
299 : dl 1.1 }
300 :    
301 : dl 1.4 /**
302 : dl 1.5 * all elements successfully put are contained
303 : dl 1.4 */
304 : jsr166 1.17 public void testPut() throws InterruptedException {
305 :     ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
306 :     for (int i = 0; i < SIZE; ++i) {
307 : jsr166 1.60 Integer x = new Integer(i);
308 :     q.put(x);
309 :     assertTrue(q.contains(x));
310 : dl 1.1 }
311 : jsr166 1.17 assertEquals(0, q.remainingCapacity());
312 : dl 1.1 }
313 :    
314 : dl 1.4 /**
315 : dl 1.5 * put blocks interruptibly if full
316 : dl 1.4 */
317 : jsr166 1.17 public void testBlockingPut() throws InterruptedException {
318 : dl 1.10 final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
319 : jsr166 1.47 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
320 :     Thread t = newStartedThread(new CheckedRunnable() {
321 : jsr166 1.25 public void realRun() throws InterruptedException {
322 :     for (int i = 0; i < SIZE; ++i)
323 :     q.put(i);
324 :     assertEquals(SIZE, q.size());
325 :     assertEquals(0, q.remainingCapacity());
326 : jsr166 1.47
327 :     Thread.currentThread().interrupt();
328 :     try {
329 :     q.put(99);
330 :     shouldThrow();
331 :     } catch (InterruptedException success) {}
332 :     assertFalse(Thread.interrupted());
333 :    
334 :     pleaseInterrupt.countDown();
335 : jsr166 1.17 try {
336 : jsr166 1.25 q.put(99);
337 :     shouldThrow();
338 :     } catch (InterruptedException success) {}
339 : jsr166 1.47 assertFalse(Thread.interrupted());
340 : jsr166 1.25 }});
341 : jsr166 1.17
342 : jsr166 1.47 await(pleaseInterrupt);
343 : jsr166 1.84 assertThreadBlocks(t, Thread.State.WAITING);
344 : jsr166 1.17 t.interrupt();
345 : jsr166 1.47 awaitTermination(t);
346 : jsr166 1.25 assertEquals(SIZE, q.size());
347 :     assertEquals(0, q.remainingCapacity());
348 : dl 1.1 }
349 :    
350 : dl 1.4 /**
351 : jsr166 1.47 * put blocks interruptibly waiting for take when full
352 : dl 1.4 */
353 : jsr166 1.17 public void testPutWithTake() throws InterruptedException {
354 : jsr166 1.27 final int capacity = 2;
355 :     final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
356 : jsr166 1.47 final CountDownLatch pleaseTake = new CountDownLatch(1);
357 :     final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
358 :     Thread t = newStartedThread(new CheckedRunnable() {
359 : jsr166 1.27 public void realRun() throws InterruptedException {
360 : jsr166 1.47 for (int i = 0; i < capacity; i++)
361 : jsr166 1.27 q.put(i);
362 : jsr166 1.47 pleaseTake.countDown();
363 :     q.put(86);
364 :    
365 : jsr166 1.89 Thread.currentThread().interrupt();
366 :     try {
367 :     q.put(99);
368 :     shouldThrow();
369 :     } catch (InterruptedException success) {}
370 :     assertFalse(Thread.interrupted());
371 :    
372 : jsr166 1.47 pleaseInterrupt.countDown();
373 : jsr166 1.17 try {
374 : jsr166 1.27 q.put(99);
375 :     shouldThrow();
376 :     } catch (InterruptedException success) {}
377 : jsr166 1.47 assertFalse(Thread.interrupted());
378 : jsr166 1.17 }});
379 :    
380 : jsr166 1.47 await(pleaseTake);
381 : jsr166 1.51 assertEquals(0, q.remainingCapacity());
382 : jsr166 1.27 assertEquals(0, q.take());
383 : jsr166 1.47
384 :     await(pleaseInterrupt);
385 : jsr166 1.83 assertThreadBlocks(t, Thread.State.WAITING);
386 : jsr166 1.17 t.interrupt();
387 : jsr166 1.47 awaitTermination(t);
388 : jsr166 1.51 assertEquals(0, q.remainingCapacity());
389 : dl 1.1 }
390 :    
391 : dl 1.4 /**
392 : dl 1.5 * timed offer times out if full and elements not taken
393 : dl 1.4 */
394 : jsr166 1.90 public void testTimedOffer() {
395 : dl 1.1 final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
396 : jsr166 1.46 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
397 :     Thread t = newStartedThread(new CheckedRunnable() {
398 : jsr166 1.17 public void realRun() throws InterruptedException {
399 :     q.put(new Object());
400 :     q.put(new Object());
401 : jsr166 1.46 long startTime = System.nanoTime();
402 :     assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
403 :     assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
404 : jsr166 1.90
405 :     Thread.currentThread().interrupt();
406 :     try {
407 :     q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
408 :     shouldThrow();
409 :     } catch (InterruptedException success) {}
410 :     assertFalse(Thread.interrupted());
411 :    
412 : jsr166 1.46 pleaseInterrupt.countDown();
413 : jsr166 1.24 try {
414 : jsr166 1.46 q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
415 : jsr166 1.24 shouldThrow();
416 :     } catch (InterruptedException success) {}
417 : jsr166 1.87 assertFalse(Thread.interrupted());
418 : jsr166 1.24 }});
419 : jsr166 1.17
420 : jsr166 1.46 await(pleaseInterrupt);
421 : jsr166 1.84 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
422 : jsr166 1.17 t.interrupt();
423 : jsr166 1.46 awaitTermination(t);
424 : dl 1.1 }
425 :    
426 : dl 1.4 /**
427 : dl 1.5 * take retrieves elements in FIFO order
428 : dl 1.4 */
429 : jsr166 1.17 public void testTake() throws InterruptedException {
430 :     ArrayBlockingQueue q = populatedQueue(SIZE);
431 :     for (int i = 0; i < SIZE; ++i) {
432 : jsr166 1.25 assertEquals(i, q.take());
433 : jsr166 1.15 }
434 : dl 1.1 }
435 :    
436 : dl 1.4 /**
437 : dl 1.5 * Take removes existing elements until empty, then blocks interruptibly
438 : dl 1.4 */
439 : jsr166 1.17 public void testBlockingTake() throws InterruptedException {
440 : jsr166 1.25 final ArrayBlockingQueue q = populatedQueue(SIZE);
441 : jsr166 1.47 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
442 :     Thread t = newStartedThread(new CheckedRunnable() {
443 : jsr166 1.17 public void realRun() throws InterruptedException {
444 : jsr166 1.82 for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
445 : jsr166 1.47
446 :     Thread.currentThread().interrupt();
447 :     try {
448 :     q.take();
449 :     shouldThrow();
450 :     } catch (InterruptedException success) {}
451 :     assertFalse(Thread.interrupted());
452 :    
453 :     pleaseInterrupt.countDown();
454 : jsr166 1.25 try {
455 :     q.take();
456 :     shouldThrow();
457 :     } catch (InterruptedException success) {}
458 : jsr166 1.47 assertFalse(Thread.interrupted());
459 : jsr166 1.25 }});
460 : jsr166 1.17
461 : jsr166 1.47 await(pleaseInterrupt);
462 : jsr166 1.82 assertThreadBlocks(t, Thread.State.WAITING);
463 : jsr166 1.25 t.interrupt();
464 : jsr166 1.47 awaitTermination(t);
465 : dl 1.1 }
466 :    
467 : dl 1.4 /**
468 : dl 1.5 * poll succeeds unless empty
469 : dl 1.4 */
470 :     public void testPoll() {
471 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
472 :     for (int i = 0; i < SIZE; ++i) {
473 : jsr166 1.25 assertEquals(i, q.poll());
474 : dl 1.1 }
475 : jsr166 1.15 assertNull(q.poll());
476 : dl 1.1 }
477 :    
478 : dl 1.4 /**
479 : jsr166 1.37 * timed poll with zero timeout succeeds when non-empty, else times out
480 : dl 1.4 */
481 : jsr166 1.17 public void testTimedPoll0() throws InterruptedException {
482 :     ArrayBlockingQueue q = populatedQueue(SIZE);
483 :     for (int i = 0; i < SIZE; ++i) {
484 : jsr166 1.25 assertEquals(i, q.poll(0, MILLISECONDS));
485 : jsr166 1.15 }
486 : jsr166 1.17 assertNull(q.poll(0, MILLISECONDS));
487 : jsr166 1.47 checkEmpty(q);
488 : dl 1.1 }
489 :    
490 : dl 1.4 /**
491 : jsr166 1.37 * timed poll with nonzero timeout succeeds when non-empty, else times out
492 : dl 1.4 */
493 : jsr166 1.17 public void testTimedPoll() throws InterruptedException {
494 :     ArrayBlockingQueue q = populatedQueue(SIZE);
495 :     for (int i = 0; i < SIZE; ++i) {
496 : jsr166 1.47 long startTime = System.nanoTime();
497 :     assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
498 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
499 :     }
500 :     long startTime = System.nanoTime();
501 :     assertNull(q.poll(timeoutMillis(), MILLISECONDS));
502 :     assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
503 :     checkEmpty(q);
504 : dl 1.1 }
505 :    
506 : dl 1.4 /**
507 : dl 1.5 * Interrupted timed poll throws InterruptedException instead of
508 :     * returning timeout status
509 : dl 1.4 */
510 : jsr166 1.17 public void testInterruptedTimedPoll() throws InterruptedException {
511 : jsr166 1.42 final BlockingQueue<Integer> q = populatedQueue(SIZE);
512 : jsr166 1.86 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
513 : jsr166 1.42 Thread t = newStartedThread(new CheckedRunnable() {
514 : jsr166 1.17 public void realRun() throws InterruptedException {
515 : jsr166 1.70 long startTime = System.nanoTime();
516 : jsr166 1.88 for (int i = 0; i < SIZE; i++)
517 : jsr166 1.70 assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
518 : jsr166 1.88
519 :     Thread.currentThread().interrupt();
520 :     try {
521 :     q.poll(LONG_DELAY_MS, MILLISECONDS);
522 :     shouldThrow();
523 :     } catch (InterruptedException success) {}
524 :     assertFalse(Thread.interrupted());
525 : jsr166 1.86
526 :     pleaseInterrupt.countDown();
527 : jsr166 1.21 try {
528 : jsr166 1.70 q.poll(LONG_DELAY_MS, MILLISECONDS);
529 : jsr166 1.22 shouldThrow();
530 : jsr166 1.86 } catch (InterruptedException success) {}
531 :     assertFalse(Thread.interrupted());
532 :    
533 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
534 : jsr166 1.21 }});
535 : jsr166 1.17
536 : jsr166 1.86 await(pleaseInterrupt);
537 : jsr166 1.85 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
538 : jsr166 1.17 t.interrupt();
539 : jsr166 1.70 awaitTermination(t);
540 : jsr166 1.42 checkEmpty(q);
541 : dl 1.1 }
542 :    
543 : dl 1.4 /**
544 : dl 1.5 * peek returns next element, or null if empty
545 : dl 1.4 */
546 :     public void testPeek() {
547 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
548 :     for (int i = 0; i < SIZE; ++i) {
549 : jsr166 1.26 assertEquals(i, q.peek());
550 :     assertEquals(i, q.poll());
551 : dl 1.1 assertTrue(q.peek() == null ||
552 : jsr166 1.26 !q.peek().equals(i));
553 : dl 1.1 }
554 : jsr166 1.15 assertNull(q.peek());
555 : dl 1.1 }
556 :    
557 : dl 1.4 /**
558 : dl 1.5 * element returns next element, or throws NSEE if empty
559 : dl 1.4 */
560 :     public void testElement() {
561 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
562 :     for (int i = 0; i < SIZE; ++i) {
563 : jsr166 1.26 assertEquals(i, q.element());
564 :     assertEquals(i, q.poll());
565 : dl 1.1 }
566 :     try {
567 :     q.element();
568 : dl 1.4 shouldThrow();
569 : jsr166 1.17 } catch (NoSuchElementException success) {}
570 : dl 1.1 }
571 :    
572 : dl 1.4 /**
573 : dl 1.5 * remove removes next element, or throws NSEE if empty
574 : dl 1.4 */
575 :     public void testRemove() {
576 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
577 :     for (int i = 0; i < SIZE; ++i) {
578 : jsr166 1.26 assertEquals(i, q.remove());
579 : dl 1.1 }
580 :     try {
581 :     q.remove();
582 : dl 1.4 shouldThrow();
583 : jsr166 1.17 } catch (NoSuchElementException success) {}
584 : dl 1.1 }
585 :    
586 : dl 1.4 /**
587 : dl 1.5 * contains(x) reports true when elements added but not yet removed
588 : dl 1.4 */
589 :     public void testContains() {
590 : jsr166 1.79 int size = ThreadLocalRandom.current().nextInt(1, SIZE);
591 :     ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
592 :     assertFalse(q.contains(null));
593 :     for (int i = 0; i < size; ++i) {
594 : dl 1.1 assertTrue(q.contains(new Integer(i)));
595 : jsr166 1.26 assertEquals(i, q.poll());
596 : dl 1.1 assertFalse(q.contains(new Integer(i)));
597 :     }
598 :     }
599 :    
600 : dl 1.4 /**
601 : dl 1.5 * clear removes all elements
602 : dl 1.4 */
603 :     public void testClear() {
604 : jsr166 1.81 int size = ThreadLocalRandom.current().nextInt(1, 5);
605 :     ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
606 :     int capacity = size + q.remainingCapacity();
607 : dl 1.1 q.clear();
608 :     assertTrue(q.isEmpty());
609 :     assertEquals(0, q.size());
610 : jsr166 1.81 assertEquals(capacity, q.remainingCapacity());
611 : dl 1.3 q.add(one);
612 : dl 1.1 assertFalse(q.isEmpty());
613 : dl 1.11 assertTrue(q.contains(one));
614 : dl 1.1 q.clear();
615 :     assertTrue(q.isEmpty());
616 :     }
617 :    
618 : dl 1.4 /**
619 : dl 1.5 * containsAll(c) is true when c contains a subset of elements
620 : dl 1.4 */
621 :     public void testContainsAll() {
622 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
623 :     ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
624 :     for (int i = 0; i < SIZE; ++i) {
625 : dl 1.1 assertTrue(q.containsAll(p));
626 :     assertFalse(p.containsAll(q));
627 :     p.add(new Integer(i));
628 :     }
629 :     assertTrue(p.containsAll(q));
630 :     }
631 :    
632 : dl 1.4 /**
633 : dl 1.5 * retainAll(c) retains only those elements of c and reports true if changed
634 : dl 1.4 */
635 :     public void testRetainAll() {
636 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
637 :     ArrayBlockingQueue p = populatedQueue(SIZE);
638 :     for (int i = 0; i < SIZE; ++i) {
639 : dl 1.1 boolean changed = q.retainAll(p);
640 :     if (i == 0)
641 :     assertFalse(changed);
642 :     else
643 :     assertTrue(changed);
644 :    
645 :     assertTrue(q.containsAll(p));
646 : jsr166 1.66 assertEquals(SIZE - i, q.size());
647 : dl 1.1 p.remove();
648 :     }
649 :     }
650 :    
651 : dl 1.4 /**
652 : dl 1.5 * removeAll(c) removes only those elements of c and reports true if changed
653 : dl 1.4 */
654 :     public void testRemoveAll() {
655 : dl 1.3 for (int i = 1; i < SIZE; ++i) {
656 :     ArrayBlockingQueue q = populatedQueue(SIZE);
657 :     ArrayBlockingQueue p = populatedQueue(i);
658 : dl 1.1 assertTrue(q.removeAll(p));
659 : jsr166 1.66 assertEquals(SIZE - i, q.size());
660 : dl 1.1 for (int j = 0; j < i; ++j) {
661 : jsr166 1.60 Integer x = (Integer)(p.remove());
662 :     assertFalse(q.contains(x));
663 : dl 1.1 }
664 :     }
665 :     }
666 :    
667 : jsr166 1.74 void checkToArray(ArrayBlockingQueue<Integer> q) {
668 : jsr166 1.55 int size = q.size();
669 : jsr166 1.74 Object[] a1 = q.toArray();
670 :     assertEquals(size, a1.length);
671 :     Integer[] a2 = q.toArray(new Integer[0]);
672 :     assertEquals(size, a2.length);
673 :     Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
674 :     assertEquals(size, a3.length);
675 :     Integer[] a4 = new Integer[size];
676 :     assertSame(a4, q.toArray(a4));
677 :     Integer[] a5 = new Integer[size + 1];
678 :     Arrays.fill(a5, 42);
679 :     assertSame(a5, q.toArray(a5));
680 :     Integer[] a6 = new Integer[size + 2];
681 :     Arrays.fill(a6, 42);
682 :     assertSame(a6, q.toArray(a6));
683 :     Object[][] as = { a1, a2, a3, a4, a5, a6 };
684 :     for (Object[] a : as) {
685 :     if (a.length > size) assertNull(a[size]);
686 :     if (a.length > size + 1) assertEquals(42, a[size + 1]);
687 :     }
688 : jsr166 1.55 Iterator it = q.iterator();
689 : jsr166 1.74 Integer s = q.peek();
690 : jsr166 1.55 for (int i = 0; i < size; i++) {
691 :     Integer x = (Integer) it.next();
692 : jsr166 1.74 assertEquals(s + i, (int) x);
693 :     for (Object[] a : as)
694 :     assertSame(a1[i], x);
695 : jsr166 1.55 }
696 :     }
697 :    
698 : dl 1.4 /**
699 : jsr166 1.74 * toArray() and toArray(a) contain all elements in FIFO order
700 : dl 1.4 */
701 : jsr166 1.40 public void testToArray() {
702 : jsr166 1.74 final ThreadLocalRandom rnd = ThreadLocalRandom.current();
703 :     final int size = rnd.nextInt(6);
704 :     final int capacity = Math.max(1, size + rnd.nextInt(size + 1));
705 :     ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
706 :     for (int i = 0; i < size; i++) {
707 : jsr166 1.55 checkToArray(q);
708 :     q.add(i);
709 :     }
710 :     // Provoke wraparound
711 : jsr166 1.74 int added = size * 2;
712 :     for (int i = 0; i < added; i++) {
713 : jsr166 1.55 checkToArray(q);
714 : jsr166 1.74 assertEquals((Integer) i, q.poll());
715 :     q.add(size + i);
716 : jsr166 1.55 }
717 : jsr166 1.74 for (int i = 0; i < size; i++) {
718 : jsr166 1.55 checkToArray(q);
719 : jsr166 1.74 assertEquals((Integer) (added + i), q.poll());
720 : jsr166 1.55 }
721 : dl 1.1 }
722 : dl 1.6
723 :     /**
724 : jsr166 1.38 * toArray(incompatible array type) throws ArrayStoreException
725 : dl 1.6 */
726 : jsr166 1.74 public void testToArray_incompatibleArrayType() {
727 : jsr166 1.26 ArrayBlockingQueue q = populatedQueue(SIZE);
728 : jsr166 1.15 try {
729 : jsr166 1.38 q.toArray(new String[10]);
730 : jsr166 1.15 shouldThrow();
731 : jsr166 1.18 } catch (ArrayStoreException success) {}
732 : jsr166 1.74 try {
733 :     q.toArray(new String[0]);
734 :     shouldThrow();
735 :     } catch (ArrayStoreException success) {}
736 : dl 1.6 }
737 :    
738 : dl 1.4 /**
739 : dl 1.5 * iterator iterates through all elements
740 : dl 1.4 */
741 : jsr166 1.17 public void testIterator() throws InterruptedException {
742 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
743 : jsr166 1.15 Iterator it = q.iterator();
744 : jsr166 1.61 int i;
745 :     for (i = 0; it.hasNext(); i++)
746 :     assertTrue(q.contains(it.next()));
747 :     assertEquals(i, SIZE);
748 :     assertIteratorExhausted(it);
749 :    
750 :     it = q.iterator();
751 :     for (i = 0; it.hasNext(); i++)
752 : jsr166 1.17 assertEquals(it.next(), q.take());
753 : jsr166 1.61 assertEquals(i, SIZE);
754 :     assertIteratorExhausted(it);
755 :     }
756 :    
757 :     /**
758 :     * iterator of empty collection has no elements
759 :     */
760 :     public void testEmptyIterator() {
761 :     assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
762 : dl 1.1 }
763 :    
764 : dl 1.4 /**
765 : dl 1.5 * iterator.remove removes current element
766 :     */
767 : jsr166 1.29 public void testIteratorRemove() {
768 : dl 1.5 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
769 :     q.add(two);
770 :     q.add(one);
771 :     q.add(three);
772 :    
773 :     Iterator it = q.iterator();
774 :     it.next();
775 :     it.remove();
776 : jsr166 1.12
777 : dl 1.5 it = q.iterator();
778 : jsr166 1.28 assertSame(it.next(), one);
779 :     assertSame(it.next(), three);
780 : dl 1.5 assertFalse(it.hasNext());
781 :     }
782 :    
783 :     /**
784 :     * iterator ordering is FIFO
785 : dl 1.4 */
786 : dl 1.1 public void testIteratorOrdering() {
787 :     final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
788 : dl 1.3 q.add(one);
789 :     q.add(two);
790 :     q.add(three);
791 : dl 1.1
792 :     assertEquals("queue should be full", 0, q.remainingCapacity());
793 :    
794 :     int k = 0;
795 :     for (Iterator it = q.iterator(); it.hasNext();) {
796 : jsr166 1.26 assertEquals(++k, it.next());
797 : dl 1.1 }
798 : dl 1.4 assertEquals(3, k);
799 : dl 1.1 }
800 :    
801 : dl 1.4 /**
802 : dl 1.5 * Modifications do not cause iterators to fail
803 : dl 1.4 */
804 : jsr166 1.29 public void testWeaklyConsistentIteration() {
805 : dl 1.1 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
806 : dl 1.3 q.add(one);
807 :     q.add(two);
808 :     q.add(three);
809 : jsr166 1.17 for (Iterator it = q.iterator(); it.hasNext();) {
810 :     q.remove();
811 :     it.next();
812 : dl 1.1 }
813 : dl 1.4 assertEquals(0, q.size());
814 : dl 1.1 }
815 :    
816 : dl 1.4 /**
817 : dl 1.5 * toString contains toStrings of elements
818 : dl 1.4 */
819 :     public void testToString() {
820 : dl 1.3 ArrayBlockingQueue q = populatedQueue(SIZE);
821 : dl 1.1 String s = q.toString();
822 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
823 : jsr166 1.47 assertTrue(s.contains(String.valueOf(i)));
824 : dl 1.1 }
825 : jsr166 1.12 }
826 : dl 1.1
827 : dl 1.4 /**
828 : dl 1.5 * offer transfers elements across Executor tasks
829 : dl 1.4 */
830 : dl 1.1 public void testOfferInExecutor() {
831 :     final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
832 : dl 1.3 q.add(one);
833 :     q.add(two);
834 : jsr166 1.47 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
835 : jsr166 1.68 final ExecutorService executor = Executors.newFixedThreadPool(2);
836 :     try (PoolCleaner cleaner = cleaner(executor)) {
837 :     executor.execute(new CheckedRunnable() {
838 :     public void realRun() throws InterruptedException {
839 :     assertFalse(q.offer(three));
840 :     threadsStarted.await();
841 :     assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
842 :     assertEquals(0, q.remainingCapacity());
843 :     }});
844 :    
845 :     executor.execute(new CheckedRunnable() {
846 :     public void realRun() throws InterruptedException {
847 :     threadsStarted.await();
848 :     assertEquals(0, q.remainingCapacity());
849 :     assertSame(one, q.take());
850 :     }});
851 :     }
852 : dl 1.1 }
853 :    
854 : dl 1.4 /**
855 : jsr166 1.47 * timed poll retrieves elements across Executor threads
856 : dl 1.4 */
857 : dl 1.1 public void testPollInExecutor() {
858 :     final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
859 : jsr166 1.47 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
860 : jsr166 1.68 final ExecutorService executor = Executors.newFixedThreadPool(2);
861 :     try (PoolCleaner cleaner = cleaner(executor)) {
862 :     executor.execute(new CheckedRunnable() {
863 :     public void realRun() throws InterruptedException {
864 :     assertNull(q.poll());
865 :     threadsStarted.await();
866 :     assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
867 :     checkEmpty(q);
868 :     }});
869 :    
870 :     executor.execute(new CheckedRunnable() {
871 :     public void realRun() throws InterruptedException {
872 :     threadsStarted.await();
873 :     q.put(one);
874 :     }});
875 :     }
876 : dl 1.1 }
877 : dl 1.2
878 : dl 1.4 /**
879 : jsr166 1.92 * A deserialized/reserialized queue has same elements in same order
880 : dl 1.4 */
881 : jsr166 1.17 public void testSerialization() throws Exception {
882 : jsr166 1.49 Queue x = populatedQueue(SIZE);
883 :     Queue y = serialClone(x);
884 : dl 1.2
885 : jsr166 1.56 assertNotSame(x, y);
886 : jsr166 1.49 assertEquals(x.size(), y.size());
887 :     assertEquals(x.toString(), y.toString());
888 :     assertTrue(Arrays.equals(x.toArray(), y.toArray()));
889 :     while (!x.isEmpty()) {
890 :     assertFalse(y.isEmpty());
891 :     assertEquals(x.remove(), y.remove());
892 :     }
893 :     assertTrue(y.isEmpty());
894 : dl 1.6 }
895 :    
896 :     /**
897 :     * drainTo(c) empties queue into another collection c
898 : jsr166 1.12 */
899 : dl 1.6 public void testDrainTo() {
900 :     ArrayBlockingQueue q = populatedQueue(SIZE);
901 :     ArrayList l = new ArrayList();
902 :     q.drainTo(l);
903 : jsr166 1.51 assertEquals(0, q.size());
904 :     assertEquals(SIZE, l.size());
905 : jsr166 1.12 for (int i = 0; i < SIZE; ++i)
906 : dl 1.6 assertEquals(l.get(i), new Integer(i));
907 : dl 1.11 q.add(zero);
908 :     q.add(one);
909 :     assertFalse(q.isEmpty());
910 :     assertTrue(q.contains(zero));
911 :     assertTrue(q.contains(one));
912 :     l.clear();
913 :     q.drainTo(l);
914 : jsr166 1.51 assertEquals(0, q.size());
915 :     assertEquals(2, l.size());
916 : jsr166 1.12 for (int i = 0; i < 2; ++i)
917 : dl 1.11 assertEquals(l.get(i), new Integer(i));
918 : dl 1.6 }
919 :    
920 :     /**
921 :     * drainTo empties full queue, unblocking a waiting put.
922 : jsr166 1.12 */
923 : jsr166 1.17 public void testDrainToWithActivePut() throws InterruptedException {
924 : dl 1.6 final ArrayBlockingQueue q = populatedQueue(SIZE);
925 : jsr166 1.17 Thread t = new Thread(new CheckedRunnable() {
926 :     public void realRun() throws InterruptedException {
927 : jsr166 1.66 q.put(new Integer(SIZE + 1));
928 : jsr166 1.17 }});
929 :    
930 :     t.start();
931 :     ArrayList l = new ArrayList();
932 :     q.drainTo(l);
933 :     assertTrue(l.size() >= SIZE);
934 :     for (int i = 0; i < SIZE; ++i)
935 :     assertEquals(l.get(i), new Integer(i));
936 :     t.join();
937 :     assertTrue(q.size() + l.size() >= SIZE);
938 : dl 1.6 }
939 :    
940 :     /**
941 : jsr166 1.34 * drainTo(c, n) empties first min(n, size) elements of queue into c
942 : jsr166 1.12 */
943 : dl 1.6 public void testDrainToN() {
944 : jsr166 1.66 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE * 2);
945 : dl 1.6 for (int i = 0; i < SIZE + 2; ++i) {
946 : jsr166 1.13 for (int j = 0; j < SIZE; j++)
947 : dl 1.11 assertTrue(q.offer(new Integer(j)));
948 : dl 1.6 ArrayList l = new ArrayList();
949 :     q.drainTo(l, i);
950 : jsr166 1.35 int k = (i < SIZE) ? i : SIZE;
951 : jsr166 1.52 assertEquals(k, l.size());
952 : jsr166 1.66 assertEquals(SIZE - k, q.size());
953 : jsr166 1.12 for (int j = 0; j < k; ++j)
954 : dl 1.6 assertEquals(l.get(j), new Integer(j));
955 : jsr166 1.59 do {} while (q.poll() != null);
956 : dl 1.2 }
957 :     }
958 :    
959 : jsr166 1.57 /**
960 :     * remove(null), contains(null) always return false
961 :     */
962 :     public void testNeverContainsNull() {
963 :     Collection<?>[] qs = {
964 : jsr166 1.80 populatedQueue(0, 1, 10, false),
965 :     populatedQueue(2, 2, 10, true),
966 : jsr166 1.57 };
967 :    
968 :     for (Collection<?> q : qs) {
969 :     assertFalse(q.contains(null));
970 :     assertFalse(q.remove(null));
971 :     }
972 :     }
973 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8