ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/LinkedTransferQueueTest.java

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.5 by jsr166, Sun Aug 2 08:17:31 2009 UTC vs.
Revision 1.46 by jsr166, Fri May 27 20:07:24 2011 UTC

#	Line 1 | Line 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	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include John Vint
6		*/
7
#	Line 13 | Line 13 | import java.io.ObjectInputStream;
13		import java.io.ObjectOutputStream;
14		import java.util.ArrayList;
15		import java.util.Arrays;
16	–	import java.util.ConcurrentModificationException;
16		import java.util.Iterator;
17	+	import java.util.List;
18		import java.util.NoSuchElementException;
19		import java.util.concurrent.*;
20	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
21	+	import static java.util.concurrent.TimeUnit.NANOSECONDS;
22		import junit.framework.Test;
23		import junit.framework.TestSuite;
24
25	+	@SuppressWarnings({"unchecked", "rawtypes"})
26		public class LinkedTransferQueueTest extends JSR166TestCase {
27
28	+	public static class Generic extends BlockingQueueTest {
29	+	protected BlockingQueue emptyCollection() {
30	+	return new LinkedTransferQueue();
31	+	}
32	+	}
33	+
34		public static void main(String[] args) {
35		junit.textui.TestRunner.run(suite());
36		}
37
38		public static Test suite() {
39	<	return new TestSuite(LinkedTransferQueueTest.class);
39	>	return newTestSuite(LinkedTransferQueueTest.class,
40	>	new Generic().testSuite());
41		}
42
43		/**
44	<	* Constructor builds new queue with size being zero and empty being true
44	>	* Constructor builds new queue with size being zero and empty
45	>	* being true
46		*/
47		public void testConstructor1() {
48		assertEquals(0, new LinkedTransferQueue().size());
#	Line 39 | Line 50 | public class LinkedTransferQueueTest ext
50		}
51
52		/**
53	<	* Initializing constructor with null collection throws NullPointerException
53	>	* Initializing constructor with null collection throws
54	>	* NullPointerException
55		*/
56		public void testConstructor2() {
57		try {
58		new LinkedTransferQueue(null);
59		shouldThrow();
60	<	} catch (NullPointerException success) {
49	<	}
60	>	} catch (NullPointerException success) {}
61		}
62
63		/**
64	<	* Initializing from Collection of null elements throws NullPointerException
64	>	* Initializing from Collection of null elements throws
65	>	* NullPointerException
66		*/
67		public void testConstructor3() {
68		try {
69		Integer[] ints = new Integer[SIZE];
70	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
70	>	new LinkedTransferQueue(Arrays.asList(ints));
71		shouldThrow();
72	<	} catch (NullPointerException success) {
61	<	}
72	>	} catch (NullPointerException success) {}
73		}
74
75		/**
#	Line 71 | Line 82 | public class LinkedTransferQueueTest ext
82		for (int i = 0; i < SIZE - 1; ++i) {
83		ints[i] = i;
84		}
85	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
85	>	new LinkedTransferQueue(Arrays.asList(ints));
86		shouldThrow();
87	<	} catch (NullPointerException success) {
77	<	}
87	>	} catch (NullPointerException success) {}
88		}
89
90		/**
91		* Queue contains all elements of the collection it is initialized by
92		*/
93		public void testConstructor5() {
94	<	try {
95	<	Integer[] ints = new Integer[SIZE];
96	<	for (int i = 0; i < SIZE; ++i) {
97	<	ints[i] = i;
98	<	}
99	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
100	<	for (int i = 0; i < SIZE; ++i) {
101	<	assertEquals(ints[i], q.poll());
102	<	}
103	<	} finally {
94	>	Integer[] ints = new Integer[SIZE];
95	>	for (int i = 0; i < SIZE; ++i) {
96	>	ints[i] = i;
97	>	}
98	>	List intList = Arrays.asList(ints);
99	>	LinkedTransferQueue q
100	>	= new LinkedTransferQueue(intList);
101	>	assertEquals(q.size(), intList.size());
102	>	assertEquals(q.toString(), intList.toString());
103	>	assertTrue(Arrays.equals(q.toArray(),
104	>	intList.toArray()));
105	>	assertTrue(Arrays.equals(q.toArray(new Object[0]),
106	>	intList.toArray(new Object[0])));
107	>	assertTrue(Arrays.equals(q.toArray(new Object[SIZE]),
108	>	intList.toArray(new Object[SIZE])));
109	>	for (int i = 0; i < SIZE; ++i) {
110	>	assertEquals(ints[i], q.poll());
111		}
112		}
113
114		/**
115	<	* Remaining capacity never decrease nor increase on add or remove
115	>	* remainingCapacity() always returns Integer.MAX_VALUE
116		*/
117		public void testRemainingCapacity() {
118		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
#	Line 119 | Line 136 | public class LinkedTransferQueueTest ext
136		LinkedTransferQueue q = new LinkedTransferQueue();
137		q.offer(null);
138		shouldThrow();
139	<	} catch (NullPointerException success) {
123	<	}
139	>	} catch (NullPointerException success) {}
140		}
141
142		/**
#	Line 131 | Line 147 | public class LinkedTransferQueueTest ext
147		LinkedTransferQueue q = new LinkedTransferQueue();
148		q.add(null);
149		shouldThrow();
150	<	} catch (NullPointerException success) {
135	<	}
150	>	} catch (NullPointerException success) {}
151		}
152
153		/**
#	Line 143 | Line 158 | public class LinkedTransferQueueTest ext
158		LinkedTransferQueue q = new LinkedTransferQueue();
159		q.addAll(null);
160		shouldThrow();
161	<	} catch (NullPointerException success) {
147	<	}
161	>	} catch (NullPointerException success) {}
162		}
163
164		/**
#	Line 155 | Line 169 | public class LinkedTransferQueueTest ext
169		LinkedTransferQueue q = populatedQueue(SIZE);
170		q.addAll(q);
171		shouldThrow();
172	<	} catch (IllegalArgumentException success) {
159	<	}
172	>	} catch (IllegalArgumentException success) {}
173		}
174
175		/**
#	Line 168 | Line 181 | public class LinkedTransferQueueTest ext
181		Integer[] ints = new Integer[SIZE];
182		q.addAll(Arrays.asList(ints));
183		shouldThrow();
184	<	} catch (NullPointerException success) {
172	<	}
184	>	} catch (NullPointerException success) {}
185		}
186
187		/**
188	<	* addAll of a collection with any null elements throws NullPointerException after
189	<	* possibly adding some elements
188	>	* addAll of a collection with any null elements throws
189	>	* NullPointerException after possibly adding some elements
190		*/
191		public void testAddAll3() {
192		try {
#	Line 185 | Line 197 | public class LinkedTransferQueueTest ext
197		}
198		q.addAll(Arrays.asList(ints));
199		shouldThrow();
200	<	} catch (NullPointerException success) {
189	<	}
200	>	} catch (NullPointerException success) {}
201		}
202
203		/**
#	Line 223 | Line 234 | public class LinkedTransferQueueTest ext
234		public void testPut() {
235		LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
236		for (int i = 0; i < SIZE; ++i) {
237	+	assertEquals(q.size(), i);
238		q.put(i);
239		assertTrue(q.contains(i));
240		}
229	–	assertEquals(q.size(), SIZE);
241		}
242
243		/**
#	Line 240 | Line 251 | public class LinkedTransferQueueTest ext
251		}
252
253		/**
254	<	* take blocks interruptibly when empty
254	>	* take removes existing elements until empty, then blocks interruptibly
255		*/
256	<	public void testTakeFromEmpty() throws InterruptedException {
257	<	final LinkedTransferQueue q = new LinkedTransferQueue();
258	<	Thread t = new Thread(new Runnable() {
259	<	public void run() {
256	>	public void testBlockingTake() throws InterruptedException {
257	>	final BlockingQueue q = populatedQueue(SIZE);
258	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
259	>	Thread t = newStartedThread(new CheckedRunnable() {
260	>	public void realRun() throws InterruptedException {
261	>	for (int i = 0; i < SIZE; ++i) {
262	>	assertEquals(i, q.take());
263	>	}
264	>
265	>	Thread.currentThread().interrupt();
266		try {
267		q.take();
268	<	threadShouldThrow();
269	<	} catch (InterruptedException success) {
270	<	} catch (Throwable ex) {
254	<	threadUnexpectedException(ex);
255	<	}
256	<	}});
257	<	t.start();
258	<	Thread.sleep(SHORT_DELAY_MS);
259	<	t.interrupt();
260	<	t.join();
261	<	}
268	>	shouldThrow();
269	>	} catch (InterruptedException success) {}
270	>	assertFalse(Thread.interrupted());
271
272	<	/**
264	<	* Take removes existing elements until empty, then blocks interruptibly
265	<	*/
266	<	public void testBlockingTake() throws InterruptedException {
267	<	Thread t = new Thread(new Runnable() {
268	<	public void run() {
272	>	pleaseInterrupt.countDown();
273		try {
270	–	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
271	–	for (int i = 0; i < SIZE; ++i) {
272	–	threadAssertEquals(i, (int) q.take());
273	–	}
274		q.take();
275	<	threadShouldThrow();
276	<	} catch (InterruptedException success) {
277	<	} catch (Throwable ex) {
278	<	threadUnexpectedException(ex);
279	<	}
275	>	shouldThrow();
276	>	} catch (InterruptedException success) {}
277	>	assertFalse(Thread.interrupted());
278		}});
279	<	t.start();
280	<	Thread.sleep(SHORT_DELAY_MS);
279	>
280	>	await(pleaseInterrupt);
281	>	assertThreadStaysAlive(t);
282		t.interrupt();
283	<	t.join();
283	>	awaitTermination(t);
284		}
285
286		/**
287		* poll succeeds unless empty
288		*/
289	<	public void testPoll() {
289	>	public void testPoll() throws InterruptedException {
290		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
291		for (int i = 0; i < SIZE; ++i) {
292		assertEquals(i, (int) q.poll());
293		}
294		assertNull(q.poll());
295	+	checkEmpty(q);
296		}
297
298		/**
299	<	* timed pool with zero timeout succeeds when non-empty, else times out
299	>	* timed poll with zero timeout succeeds when non-empty, else times out
300		*/
301		public void testTimedPoll0() throws InterruptedException {
302		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
303		for (int i = 0; i < SIZE; ++i) {
304	<	assertEquals(i, (int) q.poll(0, TimeUnit.MILLISECONDS));
304	>	assertEquals(i, (int) q.poll(0, MILLISECONDS));
305		}
306	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
306	>	assertNull(q.poll(0, MILLISECONDS));
307	>	checkEmpty(q);
308		}
309
310		/**
311	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
311	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
312		*/
313		public void testTimedPoll() throws InterruptedException {
314		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
315		for (int i = 0; i < SIZE; ++i) {
316	<	assertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
317	<	}
318	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
316	>	long startTime = System.nanoTime();
317	>	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
318	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
319	>	}
320	>	long startTime = System.nanoTime();
321	>	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
322	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
323	>	checkEmpty(q);
324		}
325
326		/**
#	Line 322 | Line 328 | public class LinkedTransferQueueTest ext
328		* returning timeout status
329		*/
330		public void testInterruptedTimedPoll() throws InterruptedException {
331	<	Thread t = new Thread(new Runnable() {
332	<	public void run() {
331	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
332	>	final CountDownLatch aboutToWait = new CountDownLatch(1);
333	>	Thread t = newStartedThread(new CheckedRunnable() {
334	>	public void realRun() throws InterruptedException {
335	>	for (int i = 0; i < SIZE; ++i) {
336	>	long t0 = System.nanoTime();
337	>	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
338	>	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
339	>	}
340	>	long t0 = System.nanoTime();
341	>	aboutToWait.countDown();
342		try {
343	<	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
344	<	for (int i = 0; i < SIZE; ++i) {
330	<	threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
331	<	}
332	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
343	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
344	>	shouldThrow();
345		} catch (InterruptedException success) {
346	<	} catch (Throwable ex) {
335	<	threadUnexpectedException(ex);
346	>	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
347		}
348		}});
349	<	t.start();
350	<	Thread.sleep(SHORT_DELAY_MS);
349	>
350	>	aboutToWait.await();
351	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
352		t.interrupt();
353	<	t.join();
353	>	awaitTermination(t, MEDIUM_DELAY_MS);
354	>	checkEmpty(q);
355		}
356
357		/**
358	<	* timed poll before a delayed offer fails; after offer succeeds;
359	<	* on interruption throws
358	>	* timed poll after thread interrupted throws InterruptedException
359	>	* instead of returning timeout status
360		*/
361	<	public void testTimedPollWithOffer() throws InterruptedException {
362	<	final LinkedTransferQueue q = new LinkedTransferQueue();
363	<	Thread t = new Thread(new Runnable() {
364	<	public void run() {
365	<	try {
366	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
367	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
368	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
369	<	threadShouldThrow();
357	<	} catch (InterruptedException success) {
358	<	} catch (Throwable ex) {
359	<	threadUnexpectedException(ex);
361	>	public void testTimedPollAfterInterrupt() throws InterruptedException {
362	>	final BlockingQueue<Integer> q = populatedQueue(SIZE);
363	>	Thread t = newStartedThread(new CheckedRunnable() {
364	>	public void realRun() throws InterruptedException {
365	>	Thread.currentThread().interrupt();
366	>	for (int i = 0; i < SIZE; ++i) {
367	>	long t0 = System.nanoTime();
368	>	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
369	>	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
370		}
371	+	try {
372	+	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
373	+	shouldThrow();
374	+	} catch (InterruptedException success) {}
375		}});
376	<	t.start();
377	<	Thread.sleep(SMALL_DELAY_MS);
378	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
365	<	t.interrupt();
366	<	t.join();
376	>
377	>	awaitTermination(t, MEDIUM_DELAY_MS);
378	>	checkEmpty(q);
379		}
380
381		/**
382		* peek returns next element, or null if empty
383		*/
384	<	public void testPeek() {
384	>	public void testPeek() throws InterruptedException {
385		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
386		for (int i = 0; i < SIZE; ++i) {
387		assertEquals(i, (int) q.peek());
#	Line 378 | Line 390 | public class LinkedTransferQueueTest ext
390		i != (int) q.peek());
391		}
392		assertNull(q.peek());
393	+	checkEmpty(q);
394		}
395
396		/**
397		* element returns next element, or throws NoSuchElementException if empty
398		*/
399	<	public void testElement() {
399	>	public void testElement() throws InterruptedException {
400		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
401		for (int i = 0; i < SIZE; ++i) {
402		assertEquals(i, (int) q.element());
#	Line 392 | Line 405 | public class LinkedTransferQueueTest ext
405		try {
406		q.element();
407		shouldThrow();
408	<	} catch (NoSuchElementException success) {
409	<	}
408	>	} catch (NoSuchElementException success) {}
409	>	checkEmpty(q);
410		}
411
412		/**
413		* remove removes next element, or throws NoSuchElementException if empty
414		*/
415	<	public void testRemove() {
415	>	public void testRemove() throws InterruptedException {
416		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
417		for (int i = 0; i < SIZE; ++i) {
418		assertEquals(i, (int) q.remove());
#	Line 407 | Line 420 | public class LinkedTransferQueueTest ext
420		try {
421		q.remove();
422		shouldThrow();
423	<	} catch (NoSuchElementException success) {
424	<	}
423	>	} catch (NoSuchElementException success) {}
424	>	checkEmpty(q);
425		}
426
427		/**
428		* remove(x) removes x and returns true if present
429		*/
430	<	public void testRemoveElement() {
430	>	public void testRemoveElement() throws InterruptedException {
431		LinkedTransferQueue q = populatedQueue(SIZE);
432	<	for (int i = 1; i < SIZE; i += 2) {
432	>	for (int i = 1; i < SIZE; i+=2) {
433	>	assertTrue(q.contains(i));
434		assertTrue(q.remove(i));
435	+	assertFalse(q.contains(i));
436	+	assertTrue(q.contains(i-1));
437		}
438	<	for (int i = 0; i < SIZE; i += 2) {
438	>	for (int i = 0; i < SIZE; i+=2) {
439	>	assertTrue(q.contains(i));
440		assertTrue(q.remove(i));
441	<	assertFalse(q.remove(i + 1));
441	>	assertFalse(q.contains(i));
442	>	assertFalse(q.remove(i+1));
443	>	assertFalse(q.contains(i+1));
444		}
445	<	assertTrue(q.isEmpty());
445	>	checkEmpty(q);
446		}
447
448		/**
#	Line 436 | Line 455 | public class LinkedTransferQueueTest ext
455		assertTrue(q.remove(one));
456		assertTrue(q.remove(two));
457		assertTrue(q.add(three));
458	<	assertTrue(q.take() != null);
458	>	assertSame(q.take(), three);
459		}
460
461		/**
#	Line 454 | Line 473 | public class LinkedTransferQueueTest ext
473		/**
474		* clear removes all elements
475		*/
476	<	public void testClear() {
476	>	public void testClear() throws InterruptedException {
477		LinkedTransferQueue q = populatedQueue(SIZE);
478		q.clear();
479	<	assertTrue(q.isEmpty());
461	<	assertEquals(0, q.size());
479	>	checkEmpty(q);
480		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
481		q.add(one);
482		assertFalse(q.isEmpty());
483	+	assertEquals(1, q.size());
484		assertTrue(q.contains(one));
485		q.clear();
486	<	assertTrue(q.isEmpty());
486	>	checkEmpty(q);
487		}
488
489		/**
#	Line 482 | Line 501 | public class LinkedTransferQueueTest ext
501		}
502
503		/**
504	<	* retainAll(c) retains only those elements of c and reports true if changed
504	>	* retainAll(c) retains only those elements of c and reports true
505	>	* if changed
506		*/
507		public void testRetainAll() {
508		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 501 | Line 521 | public class LinkedTransferQueueTest ext
521		}
522
523		/**
524	<	* removeAll(c) removes only those elements of c and reports true if changed
524	>	* removeAll(c) removes only those elements of c and reports true
525	>	* if changed
526		*/
527		public void testRemoveAll() {
528		for (int i = 1; i < SIZE; ++i) {
#	Line 516 | Line 537 | public class LinkedTransferQueueTest ext
537		}
538
539		/**
540	<	* toArray contains all elements
540	>	* toArray() contains all elements in FIFO order
541		*/
542	<	public void testToArray() throws InterruptedException {
542	>	public void testToArray() {
543		LinkedTransferQueue q = populatedQueue(SIZE);
544		Object[] o = q.toArray();
545		for (int i = 0; i < o.length; i++) {
546	<	assertEquals(o[i], q.take());
546	>	assertSame(o[i], q.poll());
547		}
548		}
549
550		/**
551	<	* toArray(a) contains all elements
551	>	* toArray(a) contains all elements in FIFO order
552		*/
553	<	public void testToArray2() throws InterruptedException {
553	>	public void testToArray2() {
554		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
555		Integer[] ints = new Integer[SIZE];
556	<	ints = q.toArray(ints);
556	>	Integer[] array = q.toArray(ints);
557	>	assertSame(ints, array);
558		for (int i = 0; i < ints.length; i++) {
559	<	assertEquals(ints[i], q.take());
559	>	assertSame(ints[i], q.poll());
560		}
561		}
562
563		/**
564		* toArray(null) throws NullPointerException
565		*/
566	<	public void testToArray_BadArg() {
566	>	public void testToArray_NullArg() {
567	>	LinkedTransferQueue q = populatedQueue(SIZE);
568		try {
569	<	LinkedTransferQueue q = populatedQueue(SIZE);
547	<	Object o[] = q.toArray(null);
569	>	q.toArray(null);
570		shouldThrow();
571	<	} catch (NullPointerException success) {
550	<	}
571	>	} catch (NullPointerException success) {}
572		}
573
574		/**
575	<	* toArray with incompatible array type throws CCE
575	>	* toArray(incompatible array type) throws ArrayStoreException
576		*/
577		public void testToArray1_BadArg() {
578	+	LinkedTransferQueue q = populatedQueue(SIZE);
579		try {
580	<	LinkedTransferQueue q = populatedQueue(SIZE);
559	<	Object o[] = q.toArray(new String[10]);
580	>	q.toArray(new String[10]);
581		shouldThrow();
582	<	} catch (ArrayStoreException success) {
562	<	}
582	>	} catch (ArrayStoreException success) {}
583		}
584
585		/**
#	Line 568 | Line 588 | public class LinkedTransferQueueTest ext
588		public void testIterator() throws InterruptedException {
589		LinkedTransferQueue q = populatedQueue(SIZE);
590		Iterator it = q.iterator();
591	+	int i = 0;
592		while (it.hasNext()) {
593	<	assertEquals(it.next(), q.take());
593	>	assertEquals(it.next(), i++);
594		}
595	+	assertEquals(i, SIZE);
596		}
597
598		/**
599	<	* iterator.remove removes current element
599	>	* iterator.remove() removes current element
600		*/
601		public void testIteratorRemove() {
602		final LinkedTransferQueue q = new LinkedTransferQueue();
#	Line 587 | Line 609 | public class LinkedTransferQueueTest ext
609		it.remove();
610
611		it = q.iterator();
612	<	assertEquals(it.next(), one);
613	<	assertEquals(it.next(), three);
612	>	assertSame(it.next(), one);
613	>	assertSame(it.next(), three);
614		assertFalse(it.hasNext());
615		}
616
#	Line 596 | Line 618 | public class LinkedTransferQueueTest ext
618		* iterator ordering is FIFO
619		*/
620		public void testIteratorOrdering() {
621	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
621	>	final LinkedTransferQueue<Integer> q
622	>	= new LinkedTransferQueue<Integer>();
623		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
624		q.add(one);
625		q.add(two);
#	Line 631 | Line 654 | public class LinkedTransferQueueTest ext
654		LinkedTransferQueue q = populatedQueue(SIZE);
655		String s = q.toString();
656		for (int i = 0; i < SIZE; ++i) {
657	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
657	>	assertTrue(s.contains(String.valueOf(i)));
658		}
659		}
660
#	Line 640 | Line 663 | public class LinkedTransferQueueTest ext
663		*/
664		public void testOfferInExecutor() {
665		final LinkedTransferQueue q = new LinkedTransferQueue();
666	<	q.add(one);
644	<	q.add(two);
666	>	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
667		ExecutorService executor = Executors.newFixedThreadPool(2);
668	<	executor.execute(new Runnable() {
669	<	public void run() {
670	<	try {
671	<	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
672	<	} catch (Throwable ex) {
651	<	threadUnexpectedException(ex);
652	<	}
668	>
669	>	executor.execute(new CheckedRunnable() {
670	>	public void realRun() throws InterruptedException {
671	>	threadsStarted.await();
672	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
673		}});
674
675	<	executor.execute(new Runnable() {
676	<	public void run() {
677	<	try {
678	<	Thread.sleep(SMALL_DELAY_MS);
679	<	threadAssertEquals(one, q.take());
660	<	} catch (Throwable ex) {
661	<	threadUnexpectedException(ex);
662	<	}
675	>	executor.execute(new CheckedRunnable() {
676	>	public void realRun() throws InterruptedException {
677	>	threadsStarted.await();
678	>	assertSame(one, q.take());
679	>	checkEmpty(q);
680		}});
681
682		joinPool(executor);
683		}
684
685		/**
686	<	* poll retrieves elements across Executor threads
686	>	* timed poll retrieves elements across Executor threads
687		*/
688		public void testPollInExecutor() {
689		final LinkedTransferQueue q = new LinkedTransferQueue();
690	+	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
691		ExecutorService executor = Executors.newFixedThreadPool(2);
692	<	executor.execute(new Runnable() {
693	<	public void run() {
694	<	try {
695	<	threadAssertNull(q.poll());
696	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
697	<	threadAssertTrue(q.isEmpty());
698	<	} catch (Throwable  ex) {
681	<	threadUnexpectedException(ex);
682	<	}
692	>
693	>	executor.execute(new CheckedRunnable() {
694	>	public void realRun() throws InterruptedException {
695	>	assertNull(q.poll());
696	>	threadsStarted.await();
697	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
698	>	checkEmpty(q);
699		}});
700
701	<	executor.execute(new Runnable() {
702	<	public void run() {
703	<	try {
704	<	Thread.sleep(SMALL_DELAY_MS);
689	<	q.put(one);
690	<	} catch (Throwable ex) {
691	<	threadUnexpectedException(ex);
692	<	}
701	>	executor.execute(new CheckedRunnable() {
702	>	public void realRun() throws InterruptedException {
703	>	threadsStarted.await();
704	>	q.put(one);
705		}});
706
707		joinPool(executor);
#	Line 702 | Line 714 | public class LinkedTransferQueueTest ext
714		LinkedTransferQueue q = populatedQueue(SIZE);
715
716		ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
717	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
717	>	ObjectOutputStream out
718	>	= new ObjectOutputStream(new BufferedOutputStream(bout));
719		out.writeObject(q);
720		out.close();
721
722	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
723	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
722	>	ByteArrayInputStream bin
723	>	= new ByteArrayInputStream(bout.toByteArray());
724	>	ObjectInputStream in
725	>	= new ObjectInputStream(new BufferedInputStream(bin));
726		LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
727
728		assertEquals(q.size(), r.size());
729	+	assertEquals(q.toString(), r.toString());
730	+	assertTrue(Arrays.equals(q.toArray(), r.toArray()));
731		while (!q.isEmpty()) {
732		assertEquals(q.remove(), r.remove());
733		}
#	Line 724 | Line 741 | public class LinkedTransferQueueTest ext
741		try {
742		q.drainTo(null);
743		shouldThrow();
744	<	} catch (NullPointerException success) {
728	<	}
744	>	} catch (NullPointerException success) {}
745		}
746
747		/**
#	Line 736 | Line 752 | public class LinkedTransferQueueTest ext
752		try {
753		q.drainTo(q);
754		shouldThrow();
755	<	} catch (IllegalArgumentException success) {
740	<	}
755	>	} catch (IllegalArgumentException success) {}
756		}
757
758		/**
#	Line 767 | Line 782 | public class LinkedTransferQueueTest ext
782		}
783
784		/**
785	<	* drainTo empties full queue, unblocking a waiting put.
785	>	* drainTo(c) empties full queue, unblocking a waiting put.
786		*/
787		public void testDrainToWithActivePut() throws InterruptedException {
788		final LinkedTransferQueue q = populatedQueue(SIZE);
789	<	Thread t = new Thread(new Runnable() {
790	<	public void run() {
791	<	try {
777	<	q.put(SIZE + 1);
778	<	} catch (Throwable ex) {
779	<	threadUnexpectedException(ex);
780	<	}
789	>	Thread t = newStartedThread(new CheckedRunnable() {
790	>	public void realRun() {
791	>	q.put(SIZE + 1);
792		}});
782	–	t.start();
793		ArrayList l = new ArrayList();
794		q.drainTo(l);
795		assertTrue(l.size() >= SIZE);
796		for (int i = 0; i < SIZE; ++i) {
797		assertEquals(l.get(i), i);
798		}
799	<	t.join();
799	>	awaitTermination(t, MEDIUM_DELAY_MS);
800		assertTrue(q.size() + l.size() >= SIZE);
801		}
802
#	Line 796 | Line 806 | public class LinkedTransferQueueTest ext
806		public void testDrainToNullN() {
807		LinkedTransferQueue q = populatedQueue(SIZE);
808		try {
809	<	q.drainTo(null, 0);
809	>	q.drainTo(null, SIZE);
810		shouldThrow();
811	<	} catch (NullPointerException success) {
802	<	}
811	>	} catch (NullPointerException success) {}
812		}
813
814		/**
#	Line 808 | Line 817 | public class LinkedTransferQueueTest ext
817		public void testDrainToSelfN() {
818		LinkedTransferQueue q = populatedQueue(SIZE);
819		try {
820	<	q.drainTo(q, 0);
820	>	q.drainTo(q, SIZE);
821		shouldThrow();
822	<	} catch (IllegalArgumentException success) {
814	<	}
822	>	} catch (IllegalArgumentException success) {}
823		}
824
825		/**
826	<	* drainTo(c, n) empties first max {n, size} elements of queue into c
826	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
827		*/
828		public void testDrainToN() {
829		LinkedTransferQueue q = new LinkedTransferQueue();
#	Line 837 | Line 845 | public class LinkedTransferQueueTest ext
845		}
846
847		/**
848	<	* poll and take should decrement the waiting consumer count
848	>	* timed poll() or take() increments the waiting consumer count;
849	>	* offer(e) decrements the waiting consumer count
850		*/
851		public void testWaitingConsumer() throws InterruptedException {
852		final LinkedTransferQueue q = new LinkedTransferQueue();
853	<	final ConsumerObserver waiting = new ConsumerObserver();
854	<	new Thread(new Runnable() {
855	<	public void run() {
856	<	try {
857	<	threadAssertTrue(q.hasWaitingConsumer());
858	<	waiting.setWaitingConsumer(q.getWaitingConsumerCount());
859	<	threadAssertTrue(q.offer(new Object()));
860	<	} catch (Throwable ex) {
861	<	threadUnexpectedException(ex);
862	<	}
863	<	}}).start();
864	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
865	<	assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
853	>	assertEquals(q.getWaitingConsumerCount(), 0);
854	>	assertFalse(q.hasWaitingConsumer());
855	>	final CountDownLatch threadStarted = new CountDownLatch(1);
856	>
857	>	Thread t = newStartedThread(new CheckedRunnable() {
858	>	public void realRun() throws InterruptedException {
859	>	threadStarted.countDown();
860	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
861	>	assertEquals(q.getWaitingConsumerCount(), 0);
862	>	assertFalse(q.hasWaitingConsumer());
863	>	}});
864	>
865	>	threadStarted.await();
866	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
867	>	assertEquals(q.getWaitingConsumerCount(), 1);
868	>	assertTrue(q.hasWaitingConsumer());
869	>
870	>	assertTrue(q.offer(one));
871	>	assertEquals(q.getWaitingConsumerCount(), 0);
872	>	assertFalse(q.hasWaitingConsumer());
873	>
874	>	awaitTermination(t, MEDIUM_DELAY_MS);
875		}
876
877		/**
#	Line 864 | Line 882 | public class LinkedTransferQueueTest ext
882		LinkedTransferQueue q = new LinkedTransferQueue();
883		q.transfer(null);
884		shouldThrow();
885	<	} catch (NullPointerException ex) {
868	<	}
885	>	} catch (NullPointerException success) {}
886		}
887
888		/**
889	<	* transfer attempts to insert into the queue then wait until that
890	<	* object is removed via take or poll.
889	>	* transfer waits until a poll occurs. The transfered element
890	>	* is returned by this associated poll.
891		*/
892		public void testTransfer2() throws InterruptedException {
893	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
894	<
895	<	new Thread(new Runnable() {
896	<	public void run() {
897	<	try {
898	<	q.transfer(SIZE);
899	<	threadAssertTrue(q.isEmpty());
900	<	} catch (Throwable ex) {
901	<	threadUnexpectedException(ex);
902	<	}
886	<	}}).start();
893	>	final LinkedTransferQueue<Integer> q
894	>	= new LinkedTransferQueue<Integer>();
895	>	final CountDownLatch threadStarted = new CountDownLatch(1);
896	>
897	>	Thread t = newStartedThread(new CheckedRunnable() {
898	>	public void realRun() throws InterruptedException {
899	>	threadStarted.countDown();
900	>	q.transfer(five);
901	>	checkEmpty(q);
902	>	}});
903
904	<	Thread.sleep(SHORT_DELAY_MS);
904	>	threadStarted.await();
905	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
906		assertEquals(1, q.size());
907	<	assertEquals(SIZE, (int) q.poll());
908	<	assertTrue(q.isEmpty());
907	>	assertSame(five, q.poll());
908	>	checkEmpty(q);
909	>	awaitTermination(t, MEDIUM_DELAY_MS);
910		}
911
912		/**
913	<	* transfer will attempt to transfer in fifo order and continue
896	<	* waiting if the element being transfered is not polled or taken
913	>	* transfer waits until a poll occurs, and then transfers in fifo order
914		*/
915		public void testTransfer3() throws InterruptedException {
916	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
916	>	final LinkedTransferQueue<Integer> q
917	>	= new LinkedTransferQueue<Integer>();
918
919	<	Thread first =
920	<	new Thread(new Runnable() {
921	<	public void run() {
922	<	try {
923	<	Integer i = SIZE + 1;
924	<	q.transfer(i);
907	<	threadAssertTrue(!q.contains(i));
908	<	threadAssertEquals(1, q.size());
909	<	} catch (Throwable ex) {
910	<	threadUnexpectedException(ex);
911	<	}
912	<	}});
913	<	first.start();
919	>	Thread first = newStartedThread(new CheckedRunnable() {
920	>	public void realRun() throws InterruptedException {
921	>	q.transfer(four);
922	>	assertTrue(!q.contains(four));
923	>	assertEquals(1, q.size());
924	>	}});
925
926	<	Thread interruptedThread =
927	<	new Thread(new Runnable() {
928	<	public void run() {
929	<	try {
930	<	while (q.size() == 0)
931	<	Thread.yield();
921	<	q.transfer(SIZE);
922	<	threadShouldThrow();
923	<	} catch (InterruptedException success) {
924	<	} catch (Throwable ex) {
925	<	threadUnexpectedException(ex);
926	<	}
926	>	Thread interruptedThread = newStartedThread(
927	>	new CheckedInterruptedRunnable() {
928	>	public void realRun() throws InterruptedException {
929	>	while (q.isEmpty())
930	>	Thread.yield();
931	>	q.transfer(five);
932		}});
928	–	interruptedThread.start();
933
934		while (q.size() < 2)
935		Thread.yield();
936		assertEquals(2, q.size());
937	<	assertEquals(SIZE + 1, (int) q.poll());
937	>	assertSame(four, q.poll());
938		first.join();
939		assertEquals(1, q.size());
940		interruptedThread.interrupt();
941		interruptedThread.join();
942	<	assertEquals(0, q.size());
939	<	assertTrue(q.isEmpty());
942	>	checkEmpty(q);
943		}
944
945		/**
946	<	* transfer will wait as long as a poll or take occurs if one does occur
947	<	* the waiting is finished and the thread that tries to poll/take
945	<	* wins in retrieving the element
946	>	* transfer waits until a poll occurs, at which point the polling
947	>	* thread returns the element
948		*/
949		public void testTransfer4() throws InterruptedException {
950		final LinkedTransferQueue q = new LinkedTransferQueue();
951	<	new Thread(new Runnable() {
952	<	public void run() {
953	<	try {
954	<	q.transfer(four);
955	<	threadAssertFalse(q.contains(four));
956	<	threadAssertEquals(three, q.poll());
957	<	} catch (Throwable ex) {
958	<	threadUnexpectedException(ex);
959	<	}
960	<	}}).start();
961	<	Thread.sleep(MEDIUM_DELAY_MS);
951	>
952	>	Thread t = newStartedThread(new CheckedRunnable() {
953	>	public void realRun() throws InterruptedException {
954	>	q.transfer(four);
955	>	assertFalse(q.contains(four));
956	>	assertSame(three, q.poll());
957	>	}});
958	>
959	>	while (q.isEmpty())
960	>	Thread.yield();
961	>	assertFalse(q.isEmpty());
962	>	assertEquals(1, q.size());
963		assertTrue(q.offer(three));
964	<	assertEquals(four, q.poll());
964	>	assertSame(four, q.poll());
965	>	awaitTermination(t, MEDIUM_DELAY_MS);
966	>	}
967	>
968	>	/**
969	>	* transfer waits until a take occurs. The transfered element
970	>	* is returned by this associated take.
971	>	*/
972	>	public void testTransfer5() throws InterruptedException {
973	>	final LinkedTransferQueue<Integer> q
974	>	= new LinkedTransferQueue<Integer>();
975	>
976	>	Thread t = newStartedThread(new CheckedRunnable() {
977	>	public void realRun() throws InterruptedException {
978	>	q.transfer(four);
979	>	checkEmpty(q);
980	>	}});
981	>
982	>	while (q.isEmpty())
983	>	Thread.yield();
984	>	assertFalse(q.isEmpty());
985	>	assertEquals(1, q.size());
986	>	assertSame(four, q.take());
987	>	checkEmpty(q);
988	>	awaitTermination(t, MEDIUM_DELAY_MS);
989		}
990
991		/**
#	Line 968 | Line 995 | public class LinkedTransferQueueTest ext
995		try {
996		final LinkedTransferQueue q = new LinkedTransferQueue();
997		q.tryTransfer(null);
998	<	this.shouldThrow();
999	<	} catch (NullPointerException ex) {
973	<	}
998	>	shouldThrow();
999	>	} catch (NullPointerException success) {}
1000		}
1001
1002		/**
1003		* tryTransfer returns false and does not enqueue if there are no
1004		* consumers waiting to poll or take.
1005		*/
1006	<	public void testTryTransfer2() {
1006	>	public void testTryTransfer2() throws InterruptedException {
1007		final LinkedTransferQueue q = new LinkedTransferQueue();
1008		assertFalse(q.tryTransfer(new Object()));
1009		assertFalse(q.hasWaitingConsumer());
1010	<	assertTrue(q.isEmpty());
985	<	assertEquals(0, q.size());
1010	>	checkEmpty(q);
1011		}
1012
1013		/**
#	Line 992 | Line 1017 | public class LinkedTransferQueueTest ext
1017		public void testTryTransfer3() throws InterruptedException {
1018		final Object hotPotato = new Object();
1019		final LinkedTransferQueue q = new LinkedTransferQueue();
1020	<	new Thread(new Runnable() {
1021	<	public void run() {
1022	<	try {
1023	<	while (! q.hasWaitingConsumer())
1024	<	Thread.yield();
1025	<	threadAssertTrue(q.hasWaitingConsumer());
1026	<	threadAssertTrue(q.isEmpty());
1027	<	threadAssertTrue(q.size() == 0);
1028	<	threadAssertTrue(q.tryTransfer(hotPotato));
1029	<	} catch (Throwable ex) {
1030	<	threadUnexpectedException(ex);
1031	<	}
1032	<	}}).start();
1008	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) == hotPotato);
1009	<	assertTrue(q.isEmpty());
1020	>
1021	>	Thread t = newStartedThread(new CheckedRunnable() {
1022	>	public void realRun() {
1023	>	while (! q.hasWaitingConsumer())
1024	>	Thread.yield();
1025	>	assertTrue(q.hasWaitingConsumer());
1026	>	checkEmpty(q);
1027	>	assertTrue(q.tryTransfer(hotPotato));
1028	>	}});
1029	>
1030	>	assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1031	>	checkEmpty(q);
1032	>	awaitTermination(t, MEDIUM_DELAY_MS);
1033		}
1034
1035		/**
#	Line 1016 | Line 1039 | public class LinkedTransferQueueTest ext
1039		public void testTryTransfer4() throws InterruptedException {
1040		final Object hotPotato = new Object();
1041		final LinkedTransferQueue q = new LinkedTransferQueue();
1042	<	new Thread(new Runnable() {
1043	<	public void run() {
1044	<	try {
1045	<	while (! q.hasWaitingConsumer())
1046	<	Thread.yield();
1047	<	threadAssertTrue(q.hasWaitingConsumer());
1048	<	threadAssertTrue(q.isEmpty());
1049	<	threadAssertTrue(q.size() == 0);
1050	<	threadAssertTrue(q.tryTransfer(hotPotato));
1051	<	} catch (Throwable ex) {
1052	<	threadUnexpectedException(ex);
1053	<	}
1054	<	}}).start();
1032	<	assertTrue(q.take() == hotPotato);
1033	<	assertTrue(q.isEmpty());
1042	>
1043	>	Thread t = newStartedThread(new CheckedRunnable() {
1044	>	public void realRun() {
1045	>	while (! q.hasWaitingConsumer())
1046	>	Thread.yield();
1047	>	assertTrue(q.hasWaitingConsumer());
1048	>	checkEmpty(q);
1049	>	assertTrue(q.tryTransfer(hotPotato));
1050	>	}});
1051	>
1052	>	assertSame(q.take(), hotPotato);
1053	>	checkEmpty(q);
1054	>	awaitTermination(t, MEDIUM_DELAY_MS);
1055		}
1056
1057		/**
1058	<	* tryTransfer waits the amount given if interrupted, show an
1038	<	* interrupted exception
1058	>	* tryTransfer blocks interruptibly if no takers
1059		*/
1060		public void testTryTransfer5() throws InterruptedException {
1061		final LinkedTransferQueue q = new LinkedTransferQueue();
1062	<	Thread toInterrupt = new Thread(new Runnable() {
1063	<	public void run() {
1062	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1063	>	assertTrue(q.isEmpty());
1064	>
1065	>	Thread t = newStartedThread(new CheckedRunnable() {
1066	>	public void realRun() throws InterruptedException {
1067	>	Thread.currentThread().interrupt();
1068		try {
1069	<	q.tryTransfer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1070	<	threadShouldThrow();
1071	<	} catch (InterruptedException success) {
1072	<	} catch (Throwable ex) {
1073	<	threadUnexpectedException(ex);
1074	<	}
1069	>	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1070	>	shouldThrow();
1071	>	} catch (InterruptedException success) {}
1072	>	assertFalse(Thread.interrupted());
1073	>
1074	>	pleaseInterrupt.countDown();
1075	>	try {
1076	>	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1077	>	shouldThrow();
1078	>	} catch (InterruptedException success) {}
1079	>	assertFalse(Thread.interrupted());
1080		}});
1081	<	toInterrupt.start();
1082	<	Thread.sleep(SMALL_DELAY_MS);
1083	<	toInterrupt.interrupt();
1081	>
1082	>	await(pleaseInterrupt);
1083	>	assertThreadStaysAlive(t);
1084	>	t.interrupt();
1085	>	awaitTermination(t);
1086	>	checkEmpty(q);
1087		}
1088
1089		/**
1090	<	* tryTransfer gives up after the timeout and return false
1090	>	* tryTransfer gives up after the timeout and returns false
1091		*/
1092		public void testTryTransfer6() throws InterruptedException {
1093		final LinkedTransferQueue q = new LinkedTransferQueue();
1094	<	new Thread(new Runnable() {
1095	<	public void run() {
1096	<	try {
1097	<	threadAssertFalse(q.tryTransfer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1098	<	} catch (Throwable ex) {
1099	<	threadUnexpectedException(ex);
1100	<	}
1101	<	}}).start();
1102	<	Thread.sleep(LONG_DELAY_MS);
1103	<	assertTrue(q.isEmpty());
1094	>
1095	>	Thread t = newStartedThread(new CheckedRunnable() {
1096	>	public void realRun() throws InterruptedException {
1097	>	long t0 = System.nanoTime();
1098	>	assertFalse(q.tryTransfer(new Object(),
1099	>	timeoutMillis(), MILLISECONDS));
1100	>	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1101	>	checkEmpty(q);
1102	>	}});
1103	>
1104	>	awaitTermination(t);
1105	>	checkEmpty(q);
1106		}
1107
1108		/**
#	Line 1078 | Line 1112 | public class LinkedTransferQueueTest ext
1112		public void testTryTransfer7() throws InterruptedException {
1113		final LinkedTransferQueue q = new LinkedTransferQueue();
1114		assertTrue(q.offer(four));
1115	<	new Thread(new Runnable() {
1116	<	public void run() {
1117	<	try {
1118	<	threadAssertTrue(q.tryTransfer(five, LONG_DELAY_MS, TimeUnit.MILLISECONDS));
1119	<	threadAssertTrue(q.isEmpty());
1120	<	} catch (Throwable ex) {
1121	<	threadUnexpectedException(ex);
1122	<	}
1123	<	}}).start();
1090	<	Thread.sleep(SHORT_DELAY_MS);
1115	>
1116	>	Thread t = newStartedThread(new CheckedRunnable() {
1117	>	public void realRun() throws InterruptedException {
1118	>	assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
1119	>	checkEmpty(q);
1120	>	}});
1121	>
1122	>	while (q.size() != 2)
1123	>	Thread.yield();
1124		assertEquals(2, q.size());
1125	<	assertEquals(four, q.poll());
1126	<	assertEquals(five, q.poll());
1127	<	assertTrue(q.isEmpty());
1125	>	assertSame(four, q.poll());
1126	>	assertSame(five, q.poll());
1127	>	checkEmpty(q);
1128	>	awaitTermination(t, MEDIUM_DELAY_MS);
1129		}
1130
1131		/**
1132	<	* tryTransfer attempts to enqueue into the q and fails returning
1133	<	* false not enqueueing and the successive poll is null
1132	>	* tryTransfer attempts to enqueue into the queue and fails
1133	>	* returning false not enqueueing and the successive poll is null
1134		*/
1135		public void testTryTransfer8() throws InterruptedException {
1136		final LinkedTransferQueue q = new LinkedTransferQueue();
1137		assertTrue(q.offer(four));
1138		assertEquals(1, q.size());
1139	<	assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1139	>	long t0 = System.nanoTime();
1140	>	assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1141	>	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1142		assertEquals(1, q.size());
1143	<	assertEquals(four, q.poll());
1108	<	threadAssertTrue(q.isEmpty());
1143	>	assertSame(four, q.poll());
1144		assertNull(q.poll());
1145	+	checkEmpty(q);
1146		}
1147
1148		private LinkedTransferQueue<Integer> populatedQueue(int n) {
1149		LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1150	<	assertTrue(q.isEmpty());
1150	>	checkEmpty(q);
1151		for (int i = 0; i < n; i++) {
1152		assertEquals(i, q.size());
1153		assertTrue(q.offer(i));
#	Line 1120 | Line 1156 | public class LinkedTransferQueueTest ext
1156		assertFalse(q.isEmpty());
1157		return q;
1158		}
1123	–
1124	–	private static class ConsumerObserver {
1125	–
1126	–	private int waitingConsumers;
1127	–
1128	–	private ConsumerObserver() {
1129	–	}
1130	–
1131	–	private void setWaitingConsumer(int i) {
1132	–	this.waitingConsumers = i;
1133	–	}
1134	–
1135	–	private int getWaitingConsumers() {
1136	–	return waitingConsumers;
1137	–	}
1138	–	}
1159		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines