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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8