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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8