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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.80 - (view) (download)

1 : dl 1.1 /*
2 :     * 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.44 * http://creativecommons.org/publicdomain/zero/1.0/
5 : dl 1.1 * Other contributors include John Vint
6 :     */
7 :    
8 : jsr166 1.55 import static java.util.concurrent.TimeUnit.MILLISECONDS;
9 :    
10 :     import java.util.ArrayList;
11 : jsr166 1.48 import java.util.Arrays;
12 : jsr166 1.47 import java.util.Collection;
13 : dl 1.1 import java.util.Iterator;
14 : jsr166 1.12 import java.util.List;
15 : dl 1.1 import java.util.NoSuchElementException;
16 : jsr166 1.48 import java.util.Queue;
17 : jsr166 1.47 import java.util.concurrent.BlockingQueue;
18 : jsr166 1.70 import java.util.concurrent.Callable;
19 : jsr166 1.47 import java.util.concurrent.CountDownLatch;
20 :     import java.util.concurrent.Executors;
21 :     import java.util.concurrent.ExecutorService;
22 :     import java.util.concurrent.LinkedTransferQueue;
23 : jsr166 1.55
24 :     import junit.framework.Test;
25 : dl 1.1
26 : jsr166 1.10 @SuppressWarnings({"unchecked", "rawtypes"})
27 : dl 1.1 public class LinkedTransferQueueTest extends JSR166TestCase {
28 : jsr166 1.25 public static class Generic extends BlockingQueueTest {
29 :     protected BlockingQueue emptyCollection() {
30 :     return new LinkedTransferQueue();
31 :     }
32 :     }
33 :    
34 : dl 1.1 public static void main(String[] args) {
35 : jsr166 1.59 main(suite(), args);
36 : dl 1.1 }
37 :    
38 :     public static Test suite() {
39 : jsr166 1.67 class Implementation implements CollectionImplementation {
40 :     public Class<?> klazz() { return LinkedTransferQueue.class; }
41 :     public Collection emptyCollection() { return new LinkedTransferQueue(); }
42 :     public Object makeElement(int i) { return i; }
43 :     public boolean isConcurrent() { return true; }
44 :     public boolean permitsNulls() { return false; }
45 :     }
46 : jsr166 1.25 return newTestSuite(LinkedTransferQueueTest.class,
47 : jsr166 1.62 new Generic().testSuite(),
48 :     CollectionTest.testSuite(new Implementation()));
49 : dl 1.1 }
50 :    
51 : jsr166 1.3 /**
52 : jsr166 1.7 * Constructor builds new queue with size being zero and empty
53 :     * being true
54 : dl 1.1 */
55 :     public void testConstructor1() {
56 :     assertEquals(0, new LinkedTransferQueue().size());
57 :     assertTrue(new LinkedTransferQueue().isEmpty());
58 :     }
59 :    
60 : jsr166 1.3 /**
61 : jsr166 1.7 * Initializing constructor with null collection throws
62 :     * NullPointerException
63 : dl 1.1 */
64 :     public void testConstructor2() {
65 :     try {
66 :     new LinkedTransferQueue(null);
67 :     shouldThrow();
68 : jsr166 1.17 } catch (NullPointerException success) {}
69 : dl 1.1 }
70 :    
71 :     /**
72 : jsr166 1.7 * Initializing from Collection of null elements throws
73 :     * NullPointerException
74 : dl 1.1 */
75 :     public void testConstructor3() {
76 : jsr166 1.47 Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
77 : dl 1.1 try {
78 : jsr166 1.47 new LinkedTransferQueue(elements);
79 : dl 1.1 shouldThrow();
80 : jsr166 1.17 } catch (NullPointerException success) {}
81 : dl 1.1 }
82 : jsr166 1.3
83 :     /**
84 : dl 1.1 * Initializing constructor with a collection containing some null elements
85 : jsr166 1.5 * throws NullPointerException
86 : dl 1.1 */
87 :     public void testConstructor4() {
88 : jsr166 1.47 Integer[] ints = new Integer[SIZE];
89 : jsr166 1.61 for (int i = 0; i < SIZE - 1; ++i)
90 : jsr166 1.47 ints[i] = i;
91 :     Collection<Integer> elements = Arrays.asList(ints);
92 : dl 1.1 try {
93 : jsr166 1.47 new LinkedTransferQueue(elements);
94 : dl 1.1 shouldThrow();
95 : jsr166 1.17 } catch (NullPointerException success) {}
96 : dl 1.1 }
97 :    
98 : jsr166 1.3 /**
99 : dl 1.1 * Queue contains all elements of the collection it is initialized by
100 :     */
101 :     public void testConstructor5() {
102 : jsr166 1.12 Integer[] ints = new Integer[SIZE];
103 :     for (int i = 0; i < SIZE; ++i) {
104 :     ints[i] = i;
105 :     }
106 :     List intList = Arrays.asList(ints);
107 :     LinkedTransferQueue q
108 :     = new LinkedTransferQueue(intList);
109 :     assertEquals(q.size(), intList.size());
110 :     assertEquals(q.toString(), intList.toString());
111 :     assertTrue(Arrays.equals(q.toArray(),
112 :     intList.toArray()));
113 :     assertTrue(Arrays.equals(q.toArray(new Object[0]),
114 :     intList.toArray(new Object[0])));
115 :     assertTrue(Arrays.equals(q.toArray(new Object[SIZE]),
116 :     intList.toArray(new Object[SIZE])));
117 :     for (int i = 0; i < SIZE; ++i) {
118 :     assertEquals(ints[i], q.poll());
119 : dl 1.1 }
120 :     }
121 :    
122 :     /**
123 : jsr166 1.12 * remainingCapacity() always returns Integer.MAX_VALUE
124 : dl 1.1 */
125 :     public void testRemainingCapacity() {
126 : jsr166 1.58 BlockingQueue q = populatedQueue(SIZE);
127 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
128 : jsr166 1.5 assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
129 : dl 1.1 assertEquals(SIZE - i, q.size());
130 : jsr166 1.58 assertEquals(i, q.remove());
131 : dl 1.1 }
132 :     for (int i = 0; i < SIZE; ++i) {
133 : jsr166 1.5 assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
134 : dl 1.1 assertEquals(i, q.size());
135 : jsr166 1.58 assertTrue(q.add(i));
136 : dl 1.1 }
137 :     }
138 :    
139 :     /**
140 : jsr166 1.5 * addAll(this) throws IllegalArgumentException
141 : dl 1.1 */
142 :     public void testAddAllSelf() {
143 : jsr166 1.60 LinkedTransferQueue q = populatedQueue(SIZE);
144 : dl 1.1 try {
145 :     q.addAll(q);
146 :     shouldThrow();
147 : jsr166 1.17 } catch (IllegalArgumentException success) {}
148 : dl 1.1 }
149 :    
150 :     /**
151 : jsr166 1.7 * addAll of a collection with any null elements throws
152 :     * NullPointerException after possibly adding some elements
153 : dl 1.1 */
154 :     public void testAddAll3() {
155 : jsr166 1.60 LinkedTransferQueue q = new LinkedTransferQueue();
156 :     Integer[] ints = new Integer[SIZE];
157 :     for (int i = 0; i < SIZE - 1; ++i)
158 :     ints[i] = i;
159 : dl 1.1 try {
160 :     q.addAll(Arrays.asList(ints));
161 :     shouldThrow();
162 : jsr166 1.17 } catch (NullPointerException success) {}
163 : dl 1.1 }
164 :    
165 :     /**
166 :     * Queue contains all elements, in traversal order, of successful addAll
167 :     */
168 :     public void testAddAll5() {
169 : jsr166 1.5 Integer[] empty = new Integer[0];
170 :     Integer[] ints = new Integer[SIZE];
171 :     for (int i = 0; i < SIZE; ++i) {
172 :     ints[i] = i;
173 :     }
174 :     LinkedTransferQueue q = new LinkedTransferQueue();
175 :     assertFalse(q.addAll(Arrays.asList(empty)));
176 :     assertTrue(q.addAll(Arrays.asList(ints)));
177 :     for (int i = 0; i < SIZE; ++i) {
178 :     assertEquals(ints[i], q.poll());
179 : dl 1.1 }
180 :     }
181 :    
182 :     /**
183 :     * all elements successfully put are contained
184 :     */
185 :     public void testPut() {
186 : jsr166 1.68 LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
187 : jsr166 1.5 for (int i = 0; i < SIZE; ++i) {
188 : jsr166 1.51 assertEquals(i, q.size());
189 : jsr166 1.5 q.put(i);
190 :     assertTrue(q.contains(i));
191 : dl 1.1 }
192 :     }
193 :    
194 :     /**
195 :     * take retrieves elements in FIFO order
196 :     */
197 : jsr166 1.5 public void testTake() throws InterruptedException {
198 :     LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
199 :     for (int i = 0; i < SIZE; ++i) {
200 :     assertEquals(i, (int) q.take());
201 : dl 1.1 }
202 :     }
203 :    
204 :     /**
205 : jsr166 1.28 * take removes existing elements until empty, then blocks interruptibly
206 : dl 1.1 */
207 : jsr166 1.5 public void testBlockingTake() throws InterruptedException {
208 : jsr166 1.46 final BlockingQueue q = populatedQueue(SIZE);
209 :     final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
210 : jsr166 1.31 Thread t = newStartedThread(new CheckedRunnable() {
211 : jsr166 1.19 public void realRun() throws InterruptedException {
212 : jsr166 1.73 for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
213 : jsr166 1.46
214 :     Thread.currentThread().interrupt();
215 :     try {
216 :     q.take();
217 :     shouldThrow();
218 :     } catch (InterruptedException success) {}
219 :     assertFalse(Thread.interrupted());
220 :    
221 :     pleaseInterrupt.countDown();
222 : jsr166 1.19 try {
223 :     q.take();
224 :     shouldThrow();
225 :     } catch (InterruptedException success) {}
226 : jsr166 1.46 assertFalse(Thread.interrupted());
227 : jsr166 1.5 }});
228 : jsr166 1.19
229 : jsr166 1.46 await(pleaseInterrupt);
230 : jsr166 1.73 assertThreadBlocks(t, Thread.State.WAITING);
231 : jsr166 1.5 t.interrupt();
232 : jsr166 1.46 awaitTermination(t);
233 : dl 1.1 }
234 :    
235 :     /**
236 :     * poll succeeds unless empty
237 :     */
238 : jsr166 1.12 public void testPoll() throws InterruptedException {
239 : jsr166 1.5 LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
240 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
241 : jsr166 1.5 assertEquals(i, (int) q.poll());
242 : dl 1.1 }
243 :     assertNull(q.poll());
244 : jsr166 1.12 checkEmpty(q);
245 : dl 1.1 }
246 :    
247 :     /**
248 : jsr166 1.30 * timed poll with zero timeout succeeds when non-empty, else times out
249 : dl 1.1 */
250 : jsr166 1.5 public void testTimedPoll0() throws InterruptedException {
251 :     LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
252 :     for (int i = 0; i < SIZE; ++i) {
253 : jsr166 1.7 assertEquals(i, (int) q.poll(0, MILLISECONDS));
254 : dl 1.1 }
255 : jsr166 1.7 assertNull(q.poll(0, MILLISECONDS));
256 : jsr166 1.12 checkEmpty(q);
257 : dl 1.1 }
258 :    
259 :     /**
260 : jsr166 1.30 * timed poll with nonzero timeout succeeds when non-empty, else times out
261 : dl 1.1 */
262 : jsr166 1.5 public void testTimedPoll() throws InterruptedException {
263 :     LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
264 : jsr166 1.66 long startTime = System.nanoTime();
265 :     for (int i = 0; i < SIZE; ++i)
266 : jsr166 1.46 assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
267 : jsr166 1.66 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
268 :    
269 :     startTime = System.nanoTime();
270 : jsr166 1.46 assertNull(q.poll(timeoutMillis(), MILLISECONDS));
271 :     assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
272 : jsr166 1.12 checkEmpty(q);
273 : dl 1.1 }
274 :    
275 :     /**
276 :     * Interrupted timed poll throws InterruptedException instead of
277 :     * returning timeout status
278 :     */
279 : jsr166 1.5 public void testInterruptedTimedPoll() throws InterruptedException {
280 : jsr166 1.31 final BlockingQueue<Integer> q = populatedQueue(SIZE);
281 : jsr166 1.76 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
282 : jsr166 1.16 Thread t = newStartedThread(new CheckedRunnable() {
283 : jsr166 1.21 public void realRun() throws InterruptedException {
284 : jsr166 1.64 long startTime = System.nanoTime();
285 : jsr166 1.78 for (int i = 0; i < SIZE; i++)
286 : jsr166 1.23 assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
287 : jsr166 1.76
288 : jsr166 1.78 Thread.currentThread().interrupt();
289 :     try {
290 :     q.poll(LONG_DELAY_MS, MILLISECONDS);
291 :     shouldThrow();
292 :     } catch (InterruptedException success) {}
293 :     assertFalse(Thread.interrupted());
294 :    
295 : jsr166 1.76 pleaseInterrupt.countDown();
296 : jsr166 1.16 try {
297 : jsr166 1.64 q.poll(LONG_DELAY_MS, MILLISECONDS);
298 : jsr166 1.17 shouldThrow();
299 : jsr166 1.66 } catch (InterruptedException success) {}
300 : jsr166 1.76 assertFalse(Thread.interrupted());
301 :    
302 : jsr166 1.66 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
303 : jsr166 1.5 }});
304 : jsr166 1.17
305 : jsr166 1.76 await(pleaseInterrupt);
306 : jsr166 1.74 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
307 : jsr166 1.5 t.interrupt();
308 : jsr166 1.64 awaitTermination(t);
309 : jsr166 1.12 checkEmpty(q);
310 : dl 1.1 }
311 :    
312 :     /**
313 : jsr166 1.31 * timed poll after thread interrupted throws InterruptedException
314 :     * instead of returning timeout status
315 :     */
316 :     public void testTimedPollAfterInterrupt() throws InterruptedException {
317 :     final BlockingQueue<Integer> q = populatedQueue(SIZE);
318 :     Thread t = newStartedThread(new CheckedRunnable() {
319 :     public void realRun() throws InterruptedException {
320 : jsr166 1.66 long startTime = System.nanoTime();
321 : jsr166 1.31 Thread.currentThread().interrupt();
322 : jsr166 1.66 for (int i = 0; i < SIZE; ++i)
323 : jsr166 1.31 assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
324 :     try {
325 : jsr166 1.66 q.poll(LONG_DELAY_MS, MILLISECONDS);
326 : jsr166 1.31 shouldThrow();
327 :     } catch (InterruptedException success) {}
328 : jsr166 1.77 assertFalse(Thread.interrupted());
329 : jsr166 1.66 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
330 : jsr166 1.31 }});
331 :    
332 : jsr166 1.66 awaitTermination(t);
333 : jsr166 1.31 checkEmpty(q);
334 :     }
335 :    
336 :     /**
337 : dl 1.1 * peek returns next element, or null if empty
338 :     */
339 : jsr166 1.12 public void testPeek() throws InterruptedException {
340 : jsr166 1.5 LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
341 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
342 : jsr166 1.5 assertEquals(i, (int) q.peek());
343 :     assertEquals(i, (int) q.poll());
344 : dl 1.1 assertTrue(q.peek() == null ||
345 : jsr166 1.5 i != (int) q.peek());
346 : dl 1.1 }
347 :     assertNull(q.peek());
348 : jsr166 1.12 checkEmpty(q);
349 : dl 1.1 }
350 :    
351 :     /**
352 : jsr166 1.5 * element returns next element, or throws NoSuchElementException if empty
353 : dl 1.1 */
354 : jsr166 1.12 public void testElement() throws InterruptedException {
355 : jsr166 1.5 LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
356 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
357 : jsr166 1.5 assertEquals(i, (int) q.element());
358 :     assertEquals(i, (int) q.poll());
359 : dl 1.1 }
360 :     try {
361 :     q.element();
362 :     shouldThrow();
363 : jsr166 1.17 } catch (NoSuchElementException success) {}
364 : jsr166 1.12 checkEmpty(q);
365 : dl 1.1 }
366 :    
367 :     /**
368 : jsr166 1.5 * remove removes next element, or throws NoSuchElementException if empty
369 : dl 1.1 */
370 : jsr166 1.12 public void testRemove() throws InterruptedException {
371 : jsr166 1.5 LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
372 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
373 : jsr166 1.5 assertEquals(i, (int) q.remove());
374 : dl 1.1 }
375 :     try {
376 :     q.remove();
377 :     shouldThrow();
378 : jsr166 1.17 } catch (NoSuchElementException success) {}
379 : jsr166 1.12 checkEmpty(q);
380 : dl 1.1 }
381 :    
382 :     /**
383 :     * An add following remove(x) succeeds
384 :     */
385 : jsr166 1.5 public void testRemoveElementAndAdd() throws InterruptedException {
386 :     LinkedTransferQueue q = new LinkedTransferQueue();
387 :     assertTrue(q.add(one));
388 :     assertTrue(q.add(two));
389 :     assertTrue(q.remove(one));
390 :     assertTrue(q.remove(two));
391 :     assertTrue(q.add(three));
392 : jsr166 1.23 assertSame(q.take(), three);
393 : dl 1.1 }
394 :    
395 :     /**
396 :     * contains(x) reports true when elements added but not yet removed
397 :     */
398 :     public void testContains() {
399 : jsr166 1.5 LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
400 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
401 : jsr166 1.5 assertTrue(q.contains(i));
402 :     assertEquals(i, (int) q.poll());
403 :     assertFalse(q.contains(i));
404 : dl 1.1 }
405 :     }
406 :    
407 :     /**
408 :     * clear removes all elements
409 :     */
410 : jsr166 1.12 public void testClear() throws InterruptedException {
411 : dl 1.1 LinkedTransferQueue q = populatedQueue(SIZE);
412 :     q.clear();
413 : jsr166 1.12 checkEmpty(q);
414 : jsr166 1.5 assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
415 : dl 1.1 q.add(one);
416 :     assertFalse(q.isEmpty());
417 : jsr166 1.12 assertEquals(1, q.size());
418 : dl 1.1 assertTrue(q.contains(one));
419 :     q.clear();
420 : jsr166 1.12 checkEmpty(q);
421 : dl 1.1 }
422 :    
423 :     /**
424 :     * containsAll(c) is true when c contains a subset of elements
425 :     */
426 :     public void testContainsAll() {
427 : jsr166 1.5 LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
428 : jsr166 1.68 LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
429 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
430 :     assertTrue(q.containsAll(p));
431 :     assertFalse(p.containsAll(q));
432 : jsr166 1.5 p.add(i);
433 : dl 1.1 }
434 :     assertTrue(p.containsAll(q));
435 :     }
436 :    
437 :     /**
438 : jsr166 1.7 * retainAll(c) retains only those elements of c and reports true
439 :     * if changed
440 : dl 1.1 */
441 :     public void testRetainAll() {
442 :     LinkedTransferQueue q = populatedQueue(SIZE);
443 :     LinkedTransferQueue p = populatedQueue(SIZE);
444 :     for (int i = 0; i < SIZE; ++i) {
445 :     boolean changed = q.retainAll(p);
446 :     if (i == 0) {
447 :     assertFalse(changed);
448 :     } else {
449 :     assertTrue(changed);
450 :     }
451 :     assertTrue(q.containsAll(p));
452 :     assertEquals(SIZE - i, q.size());
453 :     p.remove();
454 :     }
455 :     }
456 :    
457 :     /**
458 : jsr166 1.7 * removeAll(c) removes only those elements of c and reports true
459 :     * if changed
460 : dl 1.1 */
461 :     public void testRemoveAll() {
462 :     for (int i = 1; i < SIZE; ++i) {
463 :     LinkedTransferQueue q = populatedQueue(SIZE);
464 :     LinkedTransferQueue p = populatedQueue(i);
465 :     assertTrue(q.removeAll(p));
466 :     assertEquals(SIZE - i, q.size());
467 :     for (int j = 0; j < i; ++j) {
468 : jsr166 1.5 assertFalse(q.contains(p.remove()));
469 : dl 1.1 }
470 :     }
471 :     }
472 :    
473 :     /**
474 : jsr166 1.38 * toArray() contains all elements in FIFO order
475 : dl 1.1 */
476 : jsr166 1.38 public void testToArray() {
477 : dl 1.1 LinkedTransferQueue q = populatedQueue(SIZE);
478 :     Object[] o = q.toArray();
479 : jsr166 1.5 for (int i = 0; i < o.length; i++) {
480 : jsr166 1.38 assertSame(o[i], q.poll());
481 : dl 1.1 }
482 :     }
483 :    
484 :     /**
485 : jsr166 1.38 * toArray(a) contains all elements in FIFO order
486 : dl 1.1 */
487 : jsr166 1.38 public void testToArray2() {
488 : jsr166 1.5 LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
489 : dl 1.1 Integer[] ints = new Integer[SIZE];
490 : jsr166 1.39 Integer[] array = q.toArray(ints);
491 :     assertSame(ints, array);
492 : jsr166 1.5 for (int i = 0; i < ints.length; i++) {
493 : jsr166 1.38 assertSame(ints[i], q.poll());
494 : dl 1.1 }
495 :     }
496 :    
497 :     /**
498 : jsr166 1.36 * toArray(incompatible array type) throws ArrayStoreException
499 : dl 1.1 */
500 :     public void testToArray1_BadArg() {
501 : jsr166 1.20 LinkedTransferQueue q = populatedQueue(SIZE);
502 : dl 1.1 try {
503 : jsr166 1.36 q.toArray(new String[10]);
504 : dl 1.1 shouldThrow();
505 : jsr166 1.17 } catch (ArrayStoreException success) {}
506 : dl 1.1 }
507 :    
508 :     /**
509 :     * iterator iterates through all elements
510 :     */
511 : jsr166 1.5 public void testIterator() throws InterruptedException {
512 : dl 1.1 LinkedTransferQueue q = populatedQueue(SIZE);
513 :     Iterator it = q.iterator();
514 : jsr166 1.57 int i;
515 :     for (i = 0; it.hasNext(); i++)
516 :     assertTrue(q.contains(it.next()));
517 :     assertEquals(i, SIZE);
518 :     assertIteratorExhausted(it);
519 :    
520 :     it = q.iterator();
521 :     for (i = 0; it.hasNext(); i++)
522 :     assertEquals(it.next(), q.take());
523 : jsr166 1.10 assertEquals(i, SIZE);
524 : jsr166 1.57 assertIteratorExhausted(it);
525 :     }
526 :    
527 :     /**
528 :     * iterator of empty collection has no elements
529 :     */
530 :     public void testEmptyIterator() {
531 :     assertIteratorExhausted(new LinkedTransferQueue().iterator());
532 : dl 1.1 }
533 :    
534 :     /**
535 : jsr166 1.12 * iterator.remove() removes current element
536 : dl 1.1 */
537 :     public void testIteratorRemove() {
538 :     final LinkedTransferQueue q = new LinkedTransferQueue();
539 :     q.add(two);
540 :     q.add(one);
541 :     q.add(three);
542 :    
543 :     Iterator it = q.iterator();
544 :     it.next();
545 :     it.remove();
546 :    
547 :     it = q.iterator();
548 : jsr166 1.24 assertSame(it.next(), one);
549 :     assertSame(it.next(), three);
550 : dl 1.1 assertFalse(it.hasNext());
551 :     }
552 :    
553 :     /**
554 :     * iterator ordering is FIFO
555 :     */
556 :     public void testIteratorOrdering() {
557 : jsr166 1.68 final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
558 : jsr166 1.5 assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
559 : dl 1.1 q.add(one);
560 :     q.add(two);
561 :     q.add(three);
562 : jsr166 1.5 assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
563 : dl 1.1 int k = 0;
564 : jsr166 1.5 for (Integer n : q) {
565 :     assertEquals(++k, (int) n);
566 : dl 1.1 }
567 :     assertEquals(3, k);
568 :     }
569 :    
570 :     /**
571 :     * Modifications do not cause iterators to fail
572 :     */
573 :     public void testWeaklyConsistentIteration() {
574 :     final LinkedTransferQueue q = new LinkedTransferQueue();
575 :     q.add(one);
576 :     q.add(two);
577 :     q.add(three);
578 : jsr166 1.5 for (Iterator it = q.iterator(); it.hasNext();) {
579 :     q.remove();
580 :     it.next();
581 : dl 1.1 }
582 :     assertEquals(0, q.size());
583 :     }
584 :    
585 :     /**
586 :     * toString contains toStrings of elements
587 :     */
588 :     public void testToString() {
589 :     LinkedTransferQueue q = populatedQueue(SIZE);
590 :     String s = q.toString();
591 :     for (int i = 0; i < SIZE; ++i) {
592 : jsr166 1.46 assertTrue(s.contains(String.valueOf(i)));
593 : dl 1.1 }
594 :     }
595 :    
596 :     /**
597 :     * offer transfers elements across Executor tasks
598 :     */
599 :     public void testOfferInExecutor() {
600 :     final LinkedTransferQueue q = new LinkedTransferQueue();
601 : jsr166 1.46 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
602 : jsr166 1.63 final ExecutorService executor = Executors.newFixedThreadPool(2);
603 :     try (PoolCleaner cleaner = cleaner(executor)) {
604 : jsr166 1.7
605 : jsr166 1.63 executor.execute(new CheckedRunnable() {
606 :     public void realRun() throws InterruptedException {
607 :     threadsStarted.await();
608 : jsr166 1.66 long startTime = System.nanoTime();
609 : jsr166 1.63 assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
610 : jsr166 1.66 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
611 : jsr166 1.63 }});
612 : dl 1.1
613 : jsr166 1.63 executor.execute(new CheckedRunnable() {
614 :     public void realRun() throws InterruptedException {
615 :     threadsStarted.await();
616 :     assertSame(one, q.take());
617 :     checkEmpty(q);
618 :     }});
619 :     }
620 : dl 1.1 }
621 :    
622 :     /**
623 : jsr166 1.13 * timed poll retrieves elements across Executor threads
624 : dl 1.1 */
625 :     public void testPollInExecutor() {
626 :     final LinkedTransferQueue q = new LinkedTransferQueue();
627 : jsr166 1.46 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
628 : jsr166 1.63 final ExecutorService executor = Executors.newFixedThreadPool(2);
629 :     try (PoolCleaner cleaner = cleaner(executor)) {
630 : jsr166 1.7
631 : jsr166 1.63 executor.execute(new CheckedRunnable() {
632 :     public void realRun() throws InterruptedException {
633 :     assertNull(q.poll());
634 :     threadsStarted.await();
635 : jsr166 1.66 long startTime = System.nanoTime();
636 : jsr166 1.63 assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
637 : jsr166 1.66 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
638 : jsr166 1.63 checkEmpty(q);
639 :     }});
640 : dl 1.1
641 : jsr166 1.63 executor.execute(new CheckedRunnable() {
642 :     public void realRun() throws InterruptedException {
643 :     threadsStarted.await();
644 :     q.put(one);
645 :     }});
646 :     }
647 : dl 1.1 }
648 :    
649 :     /**
650 : jsr166 1.79 * A deserialized/reserialized queue has same elements in same order
651 : dl 1.1 */
652 : jsr166 1.5 public void testSerialization() throws Exception {
653 : jsr166 1.48 Queue x = populatedQueue(SIZE);
654 :     Queue y = serialClone(x);
655 : dl 1.1
656 : jsr166 1.52 assertNotSame(y, x);
657 : jsr166 1.48 assertEquals(x.size(), y.size());
658 :     assertEquals(x.toString(), y.toString());
659 :     assertTrue(Arrays.equals(x.toArray(), y.toArray()));
660 :     while (!x.isEmpty()) {
661 :     assertFalse(y.isEmpty());
662 :     assertEquals(x.remove(), y.remove());
663 : dl 1.1 }
664 : jsr166 1.48 assertTrue(y.isEmpty());
665 : dl 1.1 }
666 :    
667 :     /**
668 :     * drainTo(c) empties queue into another collection c
669 :     */
670 :     public void testDrainTo() {
671 :     LinkedTransferQueue q = populatedQueue(SIZE);
672 :     ArrayList l = new ArrayList();
673 :     q.drainTo(l);
674 : jsr166 1.50 assertEquals(0, q.size());
675 :     assertEquals(SIZE, l.size());
676 : dl 1.1 for (int i = 0; i < SIZE; ++i) {
677 : jsr166 1.51 assertEquals(i, l.get(i));
678 : dl 1.1 }
679 :     q.add(zero);
680 :     q.add(one);
681 :     assertFalse(q.isEmpty());
682 :     assertTrue(q.contains(zero));
683 :     assertTrue(q.contains(one));
684 :     l.clear();
685 :     q.drainTo(l);
686 : jsr166 1.50 assertEquals(0, q.size());
687 :     assertEquals(2, l.size());
688 : dl 1.1 for (int i = 0; i < 2; ++i) {
689 : jsr166 1.51 assertEquals(i, l.get(i));
690 : dl 1.1 }
691 :     }
692 :    
693 :     /**
694 : jsr166 1.13 * drainTo(c) empties full queue, unblocking a waiting put.
695 : dl 1.1 */
696 : jsr166 1.5 public void testDrainToWithActivePut() throws InterruptedException {
697 : dl 1.1 final LinkedTransferQueue q = populatedQueue(SIZE);
698 : jsr166 1.9 Thread t = newStartedThread(new CheckedRunnable() {
699 : jsr166 1.21 public void realRun() {
700 : jsr166 1.7 q.put(SIZE + 1);
701 : jsr166 1.5 }});
702 :     ArrayList l = new ArrayList();
703 :     q.drainTo(l);
704 :     assertTrue(l.size() >= SIZE);
705 : jsr166 1.51 for (int i = 0; i < SIZE; ++i)
706 :     assertEquals(i, l.get(i));
707 : jsr166 1.66 awaitTermination(t);
708 : jsr166 1.5 assertTrue(q.size() + l.size() >= SIZE);
709 : dl 1.1 }
710 :    
711 :     /**
712 : jsr166 1.26 * drainTo(c, n) empties first min(n, size) elements of queue into c
713 : dl 1.1 */
714 :     public void testDrainToN() {
715 :     LinkedTransferQueue q = new LinkedTransferQueue();
716 :     for (int i = 0; i < SIZE + 2; ++i) {
717 :     for (int j = 0; j < SIZE; j++) {
718 : jsr166 1.5 assertTrue(q.offer(j));
719 : dl 1.1 }
720 :     ArrayList l = new ArrayList();
721 :     q.drainTo(l, i);
722 :     int k = (i < SIZE) ? i : SIZE;
723 : jsr166 1.51 assertEquals(k, l.size());
724 :     assertEquals(SIZE - k, q.size());
725 :     for (int j = 0; j < k; ++j)
726 :     assertEquals(j, l.get(j));
727 : jsr166 1.56 do {} while (q.poll() != null);
728 : dl 1.1 }
729 :     }
730 :    
731 : jsr166 1.3 /**
732 : jsr166 1.13 * timed poll() or take() increments the waiting consumer count;
733 :     * offer(e) decrements the waiting consumer count
734 : dl 1.1 */
735 : jsr166 1.5 public void testWaitingConsumer() throws InterruptedException {
736 :     final LinkedTransferQueue q = new LinkedTransferQueue();
737 : jsr166 1.50 assertEquals(0, q.getWaitingConsumerCount());
738 : jsr166 1.13 assertFalse(q.hasWaitingConsumer());
739 : jsr166 1.31 final CountDownLatch threadStarted = new CountDownLatch(1);
740 : jsr166 1.9
741 :     Thread t = newStartedThread(new CheckedRunnable() {
742 : jsr166 1.21 public void realRun() throws InterruptedException {
743 : jsr166 1.31 threadStarted.countDown();
744 : jsr166 1.66 long startTime = System.nanoTime();
745 : jsr166 1.31 assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
746 : jsr166 1.50 assertEquals(0, q.getWaitingConsumerCount());
747 : jsr166 1.22 assertFalse(q.hasWaitingConsumer());
748 : jsr166 1.66 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
749 : jsr166 1.9 }});
750 :    
751 : jsr166 1.31 threadStarted.await();
752 : jsr166 1.70 Callable<Boolean> oneConsumer
753 :     = new Callable<Boolean>() { public Boolean call() {
754 :     return q.hasWaitingConsumer()
755 :     && q.getWaitingConsumerCount() == 1; }};
756 :     waitForThreadToEnterWaitState(t, oneConsumer);
757 : jsr166 1.31
758 :     assertTrue(q.offer(one));
759 : jsr166 1.50 assertEquals(0, q.getWaitingConsumerCount());
760 : jsr166 1.13 assertFalse(q.hasWaitingConsumer());
761 : jsr166 1.31
762 : jsr166 1.66 awaitTermination(t);
763 : dl 1.1 }
764 : jsr166 1.3
765 :     /**
766 : jsr166 1.5 * transfer(null) throws NullPointerException
767 : dl 1.1 */
768 : jsr166 1.5 public void testTransfer1() throws InterruptedException {
769 : dl 1.1 try {
770 :     LinkedTransferQueue q = new LinkedTransferQueue();
771 :     q.transfer(null);
772 :     shouldThrow();
773 : jsr166 1.15 } catch (NullPointerException success) {}
774 : dl 1.1 }
775 :    
776 : jsr166 1.3 /**
777 : jsr166 1.80 * transfer waits until a poll occurs. The transferred element
778 : jsr166 1.69 * is returned by the associated poll.
779 : dl 1.1 */
780 : jsr166 1.5 public void testTransfer2() throws InterruptedException {
781 : jsr166 1.68 final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
782 : jsr166 1.31 final CountDownLatch threadStarted = new CountDownLatch(1);
783 : jsr166 1.5
784 : jsr166 1.9 Thread t = newStartedThread(new CheckedRunnable() {
785 : jsr166 1.21 public void realRun() throws InterruptedException {
786 : jsr166 1.31 threadStarted.countDown();
787 : jsr166 1.34 q.transfer(five);
788 : jsr166 1.31 checkEmpty(q);
789 : jsr166 1.9 }});
790 : dl 1.1
791 : jsr166 1.31 threadStarted.await();
792 : jsr166 1.70 Callable<Boolean> oneElement
793 :     = new Callable<Boolean>() { public Boolean call() {
794 :     return !q.isEmpty() && q.size() == 1; }};
795 :     waitForThreadToEnterWaitState(t, oneElement);
796 :    
797 : jsr166 1.34 assertSame(five, q.poll());
798 : jsr166 1.31 checkEmpty(q);
799 : jsr166 1.66 awaitTermination(t);
800 : dl 1.1 }
801 : jsr166 1.3
802 :     /**
803 : dl 1.6 * transfer waits until a poll occurs, and then transfers in fifo order
804 : dl 1.1 */
805 : jsr166 1.5 public void testTransfer3() throws InterruptedException {
806 : jsr166 1.68 final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
807 : jsr166 1.5
808 : jsr166 1.9 Thread first = newStartedThread(new CheckedRunnable() {
809 : jsr166 1.21 public void realRun() throws InterruptedException {
810 : jsr166 1.32 q.transfer(four);
811 : jsr166 1.71 assertFalse(q.contains(four));
812 : jsr166 1.24 assertEquals(1, q.size());
813 : jsr166 1.7 }});
814 : jsr166 1.5
815 : jsr166 1.9 Thread interruptedThread = newStartedThread(
816 :     new CheckedInterruptedRunnable() {
817 : jsr166 1.21 public void realRun() throws InterruptedException {
818 : jsr166 1.32 while (q.isEmpty())
819 : jsr166 1.9 Thread.yield();
820 : jsr166 1.32 q.transfer(five);
821 : jsr166 1.9 }});
822 : jsr166 1.5
823 :     while (q.size() < 2)
824 :     Thread.yield();
825 :     assertEquals(2, q.size());
826 : jsr166 1.32 assertSame(four, q.poll());
827 : jsr166 1.5 first.join();
828 :     assertEquals(1, q.size());
829 :     interruptedThread.interrupt();
830 :     interruptedThread.join();
831 : jsr166 1.31 checkEmpty(q);
832 : dl 1.1 }
833 :    
834 :     /**
835 : dl 1.6 * transfer waits until a poll occurs, at which point the polling
836 :     * thread returns the element
837 : dl 1.1 */
838 : jsr166 1.5 public void testTransfer4() throws InterruptedException {
839 : dl 1.1 final LinkedTransferQueue q = new LinkedTransferQueue();
840 : jsr166 1.9
841 :     Thread t = newStartedThread(new CheckedRunnable() {
842 : jsr166 1.21 public void realRun() throws InterruptedException {
843 : jsr166 1.7 q.transfer(four);
844 : jsr166 1.24 assertFalse(q.contains(four));
845 :     assertSame(three, q.poll());
846 : jsr166 1.9 }});
847 :    
848 : jsr166 1.31 while (q.isEmpty())
849 :     Thread.yield();
850 :     assertFalse(q.isEmpty());
851 :     assertEquals(1, q.size());
852 : jsr166 1.5 assertTrue(q.offer(three));
853 : jsr166 1.24 assertSame(four, q.poll());
854 : jsr166 1.66 awaitTermination(t);
855 : dl 1.1 }
856 : jsr166 1.3
857 :     /**
858 : jsr166 1.80 * transfer waits until a take occurs. The transferred element
859 : jsr166 1.69 * is returned by the associated take.
860 : dl 1.6 */
861 :     public void testTransfer5() throws InterruptedException {
862 : jsr166 1.68 final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
863 : dl 1.6
864 : jsr166 1.9 Thread t = newStartedThread(new CheckedRunnable() {
865 : jsr166 1.21 public void realRun() throws InterruptedException {
866 : jsr166 1.31 q.transfer(four);
867 : jsr166 1.12 checkEmpty(q);
868 : jsr166 1.9 }});
869 : dl 1.6
870 : jsr166 1.31 while (q.isEmpty())
871 :     Thread.yield();
872 :     assertFalse(q.isEmpty());
873 :     assertEquals(1, q.size());
874 :     assertSame(four, q.take());
875 : jsr166 1.12 checkEmpty(q);
876 : jsr166 1.66 awaitTermination(t);
877 : dl 1.6 }
878 :    
879 :     /**
880 : jsr166 1.5 * tryTransfer(null) throws NullPointerException
881 : dl 1.1 */
882 :     public void testTryTransfer1() {
883 : jsr166 1.60 final LinkedTransferQueue q = new LinkedTransferQueue();
884 : dl 1.1 try {
885 :     q.tryTransfer(null);
886 : jsr166 1.8 shouldThrow();
887 : jsr166 1.15 } catch (NullPointerException success) {}
888 : dl 1.1 }
889 : jsr166 1.3
890 :     /**
891 : jsr166 1.5 * tryTransfer returns false and does not enqueue if there are no
892 :     * consumers waiting to poll or take.
893 : dl 1.1 */
894 : jsr166 1.12 public void testTryTransfer2() throws InterruptedException {
895 : jsr166 1.5 final LinkedTransferQueue q = new LinkedTransferQueue();
896 :     assertFalse(q.tryTransfer(new Object()));
897 :     assertFalse(q.hasWaitingConsumer());
898 : jsr166 1.12 checkEmpty(q);
899 : dl 1.1 }
900 : jsr166 1.3
901 :     /**
902 : jsr166 1.5 * If there is a consumer waiting in timed poll, tryTransfer
903 :     * returns true while successfully transfering object.
904 : dl 1.1 */
905 : jsr166 1.5 public void testTryTransfer3() throws InterruptedException {
906 :     final Object hotPotato = new Object();
907 :     final LinkedTransferQueue q = new LinkedTransferQueue();
908 : jsr166 1.9
909 :     Thread t = newStartedThread(new CheckedRunnable() {
910 : jsr166 1.21 public void realRun() {
911 : jsr166 1.7 while (! q.hasWaitingConsumer())
912 :     Thread.yield();
913 : jsr166 1.24 assertTrue(q.hasWaitingConsumer());
914 : jsr166 1.31 checkEmpty(q);
915 : jsr166 1.24 assertTrue(q.tryTransfer(hotPotato));
916 : jsr166 1.9 }});
917 :    
918 : jsr166 1.66 long startTime = System.nanoTime();
919 :     assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
920 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
921 : jsr166 1.12 checkEmpty(q);
922 : jsr166 1.66 awaitTermination(t);
923 : jsr166 1.5 }
924 : dl 1.1
925 : jsr166 1.5 /**
926 :     * If there is a consumer waiting in take, tryTransfer returns
927 :     * true while successfully transfering object.
928 :     */
929 :     public void testTryTransfer4() throws InterruptedException {
930 :     final Object hotPotato = new Object();
931 :     final LinkedTransferQueue q = new LinkedTransferQueue();
932 : jsr166 1.9
933 :     Thread t = newStartedThread(new CheckedRunnable() {
934 : jsr166 1.21 public void realRun() {
935 : jsr166 1.7 while (! q.hasWaitingConsumer())
936 :     Thread.yield();
937 : jsr166 1.24 assertTrue(q.hasWaitingConsumer());
938 : jsr166 1.31 checkEmpty(q);
939 : jsr166 1.24 assertTrue(q.tryTransfer(hotPotato));
940 : jsr166 1.9 }});
941 :    
942 : jsr166 1.23 assertSame(q.take(), hotPotato);
943 : jsr166 1.12 checkEmpty(q);
944 : jsr166 1.66 awaitTermination(t);
945 : dl 1.1 }
946 :    
947 : jsr166 1.3 /**
948 : jsr166 1.46 * tryTransfer blocks interruptibly if no takers
949 : dl 1.1 */
950 : jsr166 1.5 public void testTryTransfer5() throws InterruptedException {
951 : dl 1.1 final LinkedTransferQueue q = new LinkedTransferQueue();
952 : jsr166 1.46 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
953 : jsr166 1.40 assertTrue(q.isEmpty());
954 : jsr166 1.9
955 : jsr166 1.31 Thread t = newStartedThread(new CheckedRunnable() {
956 : jsr166 1.21 public void realRun() throws InterruptedException {
957 : jsr166 1.66 long startTime = System.nanoTime();
958 : jsr166 1.46 Thread.currentThread().interrupt();
959 :     try {
960 :     q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
961 :     shouldThrow();
962 :     } catch (InterruptedException success) {}
963 :     assertFalse(Thread.interrupted());
964 :    
965 :     pleaseInterrupt.countDown();
966 : jsr166 1.31 try {
967 :     q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
968 :     shouldThrow();
969 :     } catch (InterruptedException success) {}
970 : jsr166 1.46 assertFalse(Thread.interrupted());
971 : jsr166 1.66 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
972 : jsr166 1.5 }});
973 : jsr166 1.9
974 : jsr166 1.46 await(pleaseInterrupt);
975 : jsr166 1.75 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
976 : jsr166 1.31 t.interrupt();
977 : jsr166 1.46 awaitTermination(t);
978 : jsr166 1.31 checkEmpty(q);
979 : dl 1.1 }
980 :    
981 : jsr166 1.3 /**
982 : jsr166 1.33 * tryTransfer gives up after the timeout and returns false
983 : dl 1.1 */
984 : jsr166 1.5 public void testTryTransfer6() throws InterruptedException {
985 : dl 1.1 final LinkedTransferQueue q = new LinkedTransferQueue();
986 : jsr166 1.9
987 :     Thread t = newStartedThread(new CheckedRunnable() {
988 : jsr166 1.21 public void realRun() throws InterruptedException {
989 : jsr166 1.65 long startTime = System.nanoTime();
990 : jsr166 1.23 assertFalse(q.tryTransfer(new Object(),
991 : jsr166 1.46 timeoutMillis(), MILLISECONDS));
992 : jsr166 1.65 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
993 : jsr166 1.32 checkEmpty(q);
994 : jsr166 1.9 }});
995 :    
996 : jsr166 1.46 awaitTermination(t);
997 : jsr166 1.27 checkEmpty(q);
998 : dl 1.1 }
999 :    
1000 : jsr166 1.3 /**
1001 : dl 1.1 * tryTransfer waits for any elements previously in to be removed
1002 :     * before transfering to a poll or take
1003 :     */
1004 : jsr166 1.5 public void testTryTransfer7() throws InterruptedException {
1005 : dl 1.1 final LinkedTransferQueue q = new LinkedTransferQueue();
1006 : jsr166 1.5 assertTrue(q.offer(four));
1007 : jsr166 1.9
1008 :     Thread t = newStartedThread(new CheckedRunnable() {
1009 : jsr166 1.21 public void realRun() throws InterruptedException {
1010 : jsr166 1.66 long startTime = System.nanoTime();
1011 :     assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
1012 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1013 : jsr166 1.31 checkEmpty(q);
1014 : jsr166 1.9 }});
1015 :    
1016 : jsr166 1.32 while (q.size() != 2)
1017 :     Thread.yield();
1018 : jsr166 1.5 assertEquals(2, q.size());
1019 : jsr166 1.24 assertSame(four, q.poll());
1020 :     assertSame(five, q.poll());
1021 : jsr166 1.12 checkEmpty(q);
1022 : jsr166 1.66 awaitTermination(t);
1023 : dl 1.1 }
1024 :    
1025 : jsr166 1.3 /**
1026 : jsr166 1.41 * tryTransfer attempts to enqueue into the queue and fails
1027 :     * returning false not enqueueing and the successive poll is null
1028 : dl 1.1 */
1029 : jsr166 1.5 public void testTryTransfer8() throws InterruptedException {
1030 : dl 1.1 final LinkedTransferQueue q = new LinkedTransferQueue();
1031 : jsr166 1.5 assertTrue(q.offer(four));
1032 :     assertEquals(1, q.size());
1033 : jsr166 1.65 long startTime = System.nanoTime();
1034 : jsr166 1.46 assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1035 : jsr166 1.65 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1036 : jsr166 1.5 assertEquals(1, q.size());
1037 : jsr166 1.24 assertSame(four, q.poll());
1038 : jsr166 1.13 assertNull(q.poll());
1039 : jsr166 1.12 checkEmpty(q);
1040 : dl 1.1 }
1041 :    
1042 : jsr166 1.5 private LinkedTransferQueue<Integer> populatedQueue(int n) {
1043 : jsr166 1.68 LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1044 : jsr166 1.31 checkEmpty(q);
1045 : jsr166 1.5 for (int i = 0; i < n; i++) {
1046 :     assertEquals(i, q.size());
1047 : dl 1.1 assertTrue(q.offer(i));
1048 : jsr166 1.5 assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
1049 : dl 1.1 }
1050 :     assertFalse(q.isEmpty());
1051 :     return q;
1052 :     }
1053 : jsr166 1.53
1054 :     /**
1055 :     * remove(null), contains(null) always return false
1056 :     */
1057 :     public void testNeverContainsNull() {
1058 :     Collection<?>[] qs = {
1059 :     new LinkedTransferQueue<Object>(),
1060 :     populatedQueue(2),
1061 :     };
1062 :    
1063 :     for (Collection<?> q : qs) {
1064 :     assertFalse(q.contains(null));
1065 :     assertFalse(q.remove(null));
1066 :     }
1067 :     }
1068 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8