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.46 by jsr166, Fri May 27 20:07:24 2011 UTC vs.
Revision 1.69 by jsr166, Sat Feb 18 01:17:06 2017 UTC

#	Line 5 | Line 5
5		* Other contributors include John Vint
6		*/
7
8	<	import java.io.BufferedInputStream;
9	<	import java.io.BufferedOutputStream;
10	<	import java.io.ByteArrayInputStream;
11	<	import java.io.ByteArrayOutputStream;
12	<	import java.io.ObjectInputStream;
13	<	import java.io.ObjectOutputStream;
8	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
9	>
10		import java.util.ArrayList;
11		import java.util.Arrays;
12	+	import java.util.Collection;
13		import java.util.Iterator;
14		import java.util.List;
15		import java.util.NoSuchElementException;
16	<	import java.util.concurrent.*;
17	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
18	<	import static java.util.concurrent.TimeUnit.NANOSECONDS;
16	>	import java.util.Queue;
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	>	import java.util.concurrent.LinkedTransferQueue;
22	>
23		import junit.framework.Test;
23	–	import junit.framework.TestSuite;
24
25		@SuppressWarnings({"unchecked", "rawtypes"})
26		public class LinkedTransferQueueTest extends JSR166TestCase {
27	–
27		public static class Generic extends BlockingQueueTest {
28		protected BlockingQueue emptyCollection() {
29		return new LinkedTransferQueue();
#	Line 32 | Line 31 | public class LinkedTransferQueueTest ext
31		}
32
33		public static void main(String[] args) {
34	<	junit.textui.TestRunner.run(suite());
34	>	main(suite(), args);
35		}
36
37		public static Test suite() {
38	+	class Implementation implements CollectionImplementation {
39	+	public Class<?> klazz() { return LinkedTransferQueue.class; }
40	+	public Collection emptyCollection() { return new LinkedTransferQueue(); }
41	+	public Object makeElement(int i) { return i; }
42	+	public boolean isConcurrent() { return true; }
43	+	public boolean permitsNulls() { return false; }
44	+	}
45		return newTestSuite(LinkedTransferQueueTest.class,
46	<	new Generic().testSuite());
46	>	new Generic().testSuite(),
47	>	CollectionTest.testSuite(new Implementation()));
48		}
49
50		/**
#	Line 65 | Line 72 | public class LinkedTransferQueueTest ext
72		* NullPointerException
73		*/
74		public void testConstructor3() {
75	+	Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
76		try {
77	<	Integer[] ints = new Integer[SIZE];
70	<	new LinkedTransferQueue(Arrays.asList(ints));
77	>	new LinkedTransferQueue(elements);
78		shouldThrow();
79		} catch (NullPointerException success) {}
80		}
#	Line 77 | Line 84 | public class LinkedTransferQueueTest ext
84		* throws NullPointerException
85		*/
86		public void testConstructor4() {
87	+	Integer[] ints = new Integer[SIZE];
88	+	for (int i = 0; i < SIZE - 1; ++i)
89	+	ints[i] = i;
90	+	Collection<Integer> elements = Arrays.asList(ints);
91		try {
92	<	Integer[] ints = new Integer[SIZE];
82	<	for (int i = 0; i < SIZE - 1; ++i) {
83	<	ints[i] = i;
84	<	}
85	<	new LinkedTransferQueue(Arrays.asList(ints));
92	>	new LinkedTransferQueue(elements);
93		shouldThrow();
94		} catch (NullPointerException success) {}
95		}
#	Line 115 | Line 122 | public class LinkedTransferQueueTest ext
122		* remainingCapacity() always returns Integer.MAX_VALUE
123		*/
124		public void testRemainingCapacity() {
125	<	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
125	>	BlockingQueue q = populatedQueue(SIZE);
126		for (int i = 0; i < SIZE; ++i) {
127		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
128		assertEquals(SIZE - i, q.size());
129	<	q.remove();
129	>	assertEquals(i, q.remove());
130		}
131		for (int i = 0; i < SIZE; ++i) {
132		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
133		assertEquals(i, q.size());
134	<	q.add(i);
134	>	assertTrue(q.add(i));
135		}
136		}
137
138		/**
132	–	* offer(null) throws NullPointerException
133	–	*/
134	–	public void testOfferNull() {
135	–	try {
136	–	LinkedTransferQueue q = new LinkedTransferQueue();
137	–	q.offer(null);
138	–	shouldThrow();
139	–	} catch (NullPointerException success) {}
140	–	}
141	–
142	–	/**
143	–	* add(null) throws NullPointerException
144	–	*/
145	–	public void testAddNull() {
146	–	try {
147	–	LinkedTransferQueue q = new LinkedTransferQueue();
148	–	q.add(null);
149	–	shouldThrow();
150	–	} catch (NullPointerException success) {}
151	–	}
152	–
153	–	/**
154	–	* addAll(null) throws NullPointerException
155	–	*/
156	–	public void testAddAll1() {
157	–	try {
158	–	LinkedTransferQueue q = new LinkedTransferQueue();
159	–	q.addAll(null);
160	–	shouldThrow();
161	–	} catch (NullPointerException success) {}
162	–	}
163	–
164	–	/**
139		* addAll(this) throws IllegalArgumentException
140		*/
141		public void testAddAllSelf() {
142	+	LinkedTransferQueue q = populatedQueue(SIZE);
143		try {
169	–	LinkedTransferQueue q = populatedQueue(SIZE);
144		q.addAll(q);
145		shouldThrow();
146		} catch (IllegalArgumentException success) {}
147		}
148
149		/**
176	–	* addAll of a collection with null elements throws NullPointerException
177	–	*/
178	–	public void testAddAll2() {
179	–	try {
180	–	LinkedTransferQueue q = new LinkedTransferQueue();
181	–	Integer[] ints = new Integer[SIZE];
182	–	q.addAll(Arrays.asList(ints));
183	–	shouldThrow();
184	–	} catch (NullPointerException success) {}
185	–	}
186	–
187	–	/**
150		* addAll of a collection with any null elements throws
151		* NullPointerException after possibly adding some elements
152		*/
153		public void testAddAll3() {
154	+	LinkedTransferQueue q = new LinkedTransferQueue();
155	+	Integer[] ints = new Integer[SIZE];
156	+	for (int i = 0; i < SIZE - 1; ++i)
157	+	ints[i] = i;
158		try {
193	–	LinkedTransferQueue q = new LinkedTransferQueue();
194	–	Integer[] ints = new Integer[SIZE];
195	–	for (int i = 0; i < SIZE - 1; ++i) {
196	–	ints[i] = i;
197	–	}
159		q.addAll(Arrays.asList(ints));
160		shouldThrow();
161		} catch (NullPointerException success) {}
#	Line 218 | Line 179 | public class LinkedTransferQueueTest ext
179		}
180
181		/**
221	–	* put(null) throws NullPointerException
222	–	*/
223	–	public void testPutNull() throws InterruptedException {
224	–	try {
225	–	LinkedTransferQueue q = new LinkedTransferQueue();
226	–	q.put(null);
227	–	shouldThrow();
228	–	} catch (NullPointerException success) {}
229	–	}
230	–
231	–	/**
182		* all elements successfully put are contained
183		*/
184		public void testPut() {
185	<	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
185	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
186		for (int i = 0; i < SIZE; ++i) {
187	<	assertEquals(q.size(), i);
187	>	assertEquals(i, q.size());
188		q.put(i);
189		assertTrue(q.contains(i));
190		}
#	Line 312 | Line 262 | public class LinkedTransferQueueTest ext
262		*/
263		public void testTimedPoll() throws InterruptedException {
264		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
315	–	for (int i = 0; i < SIZE; ++i) {
316	–	long startTime = System.nanoTime();
317	–	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
318	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
319	–	}
265		long startTime = System.nanoTime();
266	+	for (int i = 0; i < SIZE; ++i)
267	+	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
268	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
269	+
270	+	startTime = System.nanoTime();
271		assertNull(q.poll(timeoutMillis(), MILLISECONDS));
272		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
273		checkEmpty(q);
#	Line 332 | Line 282 | public class LinkedTransferQueueTest ext
282		final CountDownLatch aboutToWait = new CountDownLatch(1);
283		Thread t = newStartedThread(new CheckedRunnable() {
284		public void realRun() throws InterruptedException {
285	<	for (int i = 0; i < SIZE; ++i) {
286	<	long t0 = System.nanoTime();
285	>	long startTime = System.nanoTime();
286	>	for (int i = 0; i < SIZE; ++i)
287		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
338	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
339	–	}
340	–	long t0 = System.nanoTime();
288		aboutToWait.countDown();
289		try {
290	<	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
290	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
291		shouldThrow();
292	<	} catch (InterruptedException success) {
293	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
347	<	}
292	>	} catch (InterruptedException success) {}
293	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
294		}});
295
296		aboutToWait.await();
297	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
297	>	waitForThreadToEnterWaitState(t);
298		t.interrupt();
299	<	awaitTermination(t, MEDIUM_DELAY_MS);
299	>	awaitTermination(t);
300		checkEmpty(q);
301		}
302
#	Line 362 | Line 308 | public class LinkedTransferQueueTest ext
308		final BlockingQueue<Integer> q = populatedQueue(SIZE);
309		Thread t = newStartedThread(new CheckedRunnable() {
310		public void realRun() throws InterruptedException {
311	+	long startTime = System.nanoTime();
312		Thread.currentThread().interrupt();
313	<	for (int i = 0; i < SIZE; ++i) {
367	<	long t0 = System.nanoTime();
313	>	for (int i = 0; i < SIZE; ++i)
314		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
369	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
370	–	}
315		try {
316	<	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
316	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
317		shouldThrow();
318		} catch (InterruptedException success) {}
319	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
320		}});
321
322	<	awaitTermination(t, MEDIUM_DELAY_MS);
322	>	awaitTermination(t);
323		checkEmpty(q);
324		}
325
#	Line 425 | Line 370 | public class LinkedTransferQueueTest ext
370		}
371
372		/**
428	–	* remove(x) removes x and returns true if present
429	–	*/
430	–	public void testRemoveElement() throws InterruptedException {
431	–	LinkedTransferQueue q = populatedQueue(SIZE);
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) {
439	–	assertTrue(q.contains(i));
440	–	assertTrue(q.remove(i));
441	–	assertFalse(q.contains(i));
442	–	assertFalse(q.remove(i+1));
443	–	assertFalse(q.contains(i+1));
444	–	}
445	–	checkEmpty(q);
446	–	}
447	–
448	–	/**
373		* An add following remove(x) succeeds
374		*/
375		public void testRemoveElementAndAdd() throws InterruptedException {
#	Line 491 | Line 415 | public class LinkedTransferQueueTest ext
415		*/
416		public void testContainsAll() {
417		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
418	<	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
418	>	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
419		for (int i = 0; i < SIZE; ++i) {
420		assertTrue(q.containsAll(p));
421		assertFalse(p.containsAll(q));
#	Line 561 | Line 485 | public class LinkedTransferQueueTest ext
485		}
486
487		/**
564	–	* toArray(null) throws NullPointerException
565	–	*/
566	–	public void testToArray_NullArg() {
567	–	LinkedTransferQueue q = populatedQueue(SIZE);
568	–	try {
569	–	q.toArray(null);
570	–	shouldThrow();
571	–	} catch (NullPointerException success) {}
572	–	}
573	–
574	–	/**
488		* toArray(incompatible array type) throws ArrayStoreException
489		*/
490		public void testToArray1_BadArg() {
#	Line 588 | Line 501 | public class LinkedTransferQueueTest ext
501		public void testIterator() throws InterruptedException {
502		LinkedTransferQueue q = populatedQueue(SIZE);
503		Iterator it = q.iterator();
504	<	int i = 0;
505	<	while (it.hasNext()) {
506	<	assertEquals(it.next(), i++);
507	<	}
504	>	int i;
505	>	for (i = 0; it.hasNext(); i++)
506	>	assertTrue(q.contains(it.next()));
507	>	assertEquals(i, SIZE);
508	>	assertIteratorExhausted(it);
509	>
510	>	it = q.iterator();
511	>	for (i = 0; it.hasNext(); i++)
512	>	assertEquals(it.next(), q.take());
513		assertEquals(i, SIZE);
514	+	assertIteratorExhausted(it);
515	+	}
516	+
517	+	/**
518	+	* iterator of empty collection has no elements
519	+	*/
520	+	public void testEmptyIterator() {
521	+	assertIteratorExhausted(new LinkedTransferQueue().iterator());
522		}
523
524		/**
#	Line 618 | Line 544 | public class LinkedTransferQueueTest ext
544		* iterator ordering is FIFO
545		*/
546		public void testIteratorOrdering() {
547	<	final LinkedTransferQueue<Integer> q
622	<	= new LinkedTransferQueue<Integer>();
547	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
548		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
549		q.add(one);
550		q.add(two);
#	Line 664 | Line 589 | public class LinkedTransferQueueTest ext
589		public void testOfferInExecutor() {
590		final LinkedTransferQueue q = new LinkedTransferQueue();
591		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
592	<	ExecutorService executor = Executors.newFixedThreadPool(2);
592	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
593	>	try (PoolCleaner cleaner = cleaner(executor)) {
594
595	<	executor.execute(new CheckedRunnable() {
596	<	public void realRun() throws InterruptedException {
597	<	threadsStarted.await();
598	<	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
599	<	}});
600	<
601	<	executor.execute(new CheckedRunnable() {
676	<	public void realRun() throws InterruptedException {
677	<	threadsStarted.await();
678	<	assertSame(one, q.take());
679	<	checkEmpty(q);
680	<	}});
595	>	executor.execute(new CheckedRunnable() {
596	>	public void realRun() throws InterruptedException {
597	>	threadsStarted.await();
598	>	long startTime = System.nanoTime();
599	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
600	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
601	>	}});
602
603	<	joinPool(executor);
603	>	executor.execute(new CheckedRunnable() {
604	>	public void realRun() throws InterruptedException {
605	>	threadsStarted.await();
606	>	assertSame(one, q.take());
607	>	checkEmpty(q);
608	>	}});
609	>	}
610		}
611
612		/**
#	Line 688 | Line 615 | public class LinkedTransferQueueTest ext
615		public void testPollInExecutor() {
616		final LinkedTransferQueue q = new LinkedTransferQueue();
617		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
618	<	ExecutorService executor = Executors.newFixedThreadPool(2);
618	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
619	>	try (PoolCleaner cleaner = cleaner(executor)) {
620
621	<	executor.execute(new CheckedRunnable() {
622	<	public void realRun() throws InterruptedException {
623	<	assertNull(q.poll());
624	<	threadsStarted.await();
625	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
626	<	checkEmpty(q);
627	<	}});
628	<
629	<	executor.execute(new CheckedRunnable() {
702	<	public void realRun() throws InterruptedException {
703	<	threadsStarted.await();
704	<	q.put(one);
705	<	}});
621	>	executor.execute(new CheckedRunnable() {
622	>	public void realRun() throws InterruptedException {
623	>	assertNull(q.poll());
624	>	threadsStarted.await();
625	>	long startTime = System.nanoTime();
626	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
627	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
628	>	checkEmpty(q);
629	>	}});
630
631	<	joinPool(executor);
631	>	executor.execute(new CheckedRunnable() {
632	>	public void realRun() throws InterruptedException {
633	>	threadsStarted.await();
634	>	q.put(one);
635	>	}});
636	>	}
637		}
638
639		/**
640		* A deserialized serialized queue has same elements in same order
641		*/
642		public void testSerialization() throws Exception {
643	<	LinkedTransferQueue q = populatedQueue(SIZE);
643	>	Queue x = populatedQueue(SIZE);
644	>	Queue y = serialClone(x);
645
646	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
647	<	ObjectOutputStream out
648	<	= new ObjectOutputStream(new BufferedOutputStream(bout));
649	<	out.writeObject(q);
650	<	out.close();
651	<
652	<	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());
646	>	assertNotSame(y, x);
647	>	assertEquals(x.size(), y.size());
648	>	assertEquals(x.toString(), y.toString());
649	>	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
650	>	while (!x.isEmpty()) {
651	>	assertFalse(y.isEmpty());
652	>	assertEquals(x.remove(), y.remove());
653		}
654	<	}
735	<
736	<	/**
737	<	* drainTo(null) throws NullPointerException
738	<	*/
739	<	public void testDrainToNull() {
740	<	LinkedTransferQueue q = populatedQueue(SIZE);
741	<	try {
742	<	q.drainTo(null);
743	<	shouldThrow();
744	<	} catch (NullPointerException success) {}
745	<	}
746	<
747	<	/**
748	<	* drainTo(this) throws IllegalArgumentException
749	<	*/
750	<	public void testDrainToSelf() {
751	<	LinkedTransferQueue q = populatedQueue(SIZE);
752	<	try {
753	<	q.drainTo(q);
754	<	shouldThrow();
755	<	} catch (IllegalArgumentException success) {}
654	>	assertTrue(y.isEmpty());
655		}
656
657		/**
#	Line 762 | Line 661 | public class LinkedTransferQueueTest ext
661		LinkedTransferQueue q = populatedQueue(SIZE);
662		ArrayList l = new ArrayList();
663		q.drainTo(l);
664	<	assertEquals(q.size(), 0);
665	<	assertEquals(l.size(), SIZE);
664	>	assertEquals(0, q.size());
665	>	assertEquals(SIZE, l.size());
666		for (int i = 0; i < SIZE; ++i) {
667	<	assertEquals(l.get(i), i);
667	>	assertEquals(i, l.get(i));
668		}
669		q.add(zero);
670		q.add(one);
#	Line 774 | Line 673 | public class LinkedTransferQueueTest ext
673		assertTrue(q.contains(one));
674		l.clear();
675		q.drainTo(l);
676	<	assertEquals(q.size(), 0);
677	<	assertEquals(l.size(), 2);
676	>	assertEquals(0, q.size());
677	>	assertEquals(2, l.size());
678		for (int i = 0; i < 2; ++i) {
679	<	assertEquals(l.get(i), i);
679	>	assertEquals(i, l.get(i));
680		}
681		}
682
#	Line 793 | Line 692 | public class LinkedTransferQueueTest ext
692		ArrayList l = new ArrayList();
693		q.drainTo(l);
694		assertTrue(l.size() >= SIZE);
695	<	for (int i = 0; i < SIZE; ++i) {
696	<	assertEquals(l.get(i), i);
697	<	}
799	<	awaitTermination(t, MEDIUM_DELAY_MS);
695	>	for (int i = 0; i < SIZE; ++i)
696	>	assertEquals(i, l.get(i));
697	>	awaitTermination(t);
698		assertTrue(q.size() + l.size() >= SIZE);
699		}
700
701		/**
804	–	* drainTo(null, n) throws NullPointerException
805	–	*/
806	–	public void testDrainToNullN() {
807	–	LinkedTransferQueue q = populatedQueue(SIZE);
808	–	try {
809	–	q.drainTo(null, SIZE);
810	–	shouldThrow();
811	–	} catch (NullPointerException success) {}
812	–	}
813	–
814	–	/**
815	–	* drainTo(this, n) throws IllegalArgumentException
816	–	*/
817	–	public void testDrainToSelfN() {
818	–	LinkedTransferQueue q = populatedQueue(SIZE);
819	–	try {
820	–	q.drainTo(q, SIZE);
821	–	shouldThrow();
822	–	} catch (IllegalArgumentException success) {}
823	–	}
824	–
825	–	/**
702		* drainTo(c, n) empties first min(n, size) elements of queue into c
703		*/
704		public void testDrainToN() {
#	Line 834 | Line 710 | public class LinkedTransferQueueTest ext
710		ArrayList l = new ArrayList();
711		q.drainTo(l, i);
712		int k = (i < SIZE) ? i : SIZE;
713	<	assertEquals(l.size(), k);
714	<	assertEquals(q.size(), SIZE - k);
715	<	for (int j = 0; j < k; ++j) {
716	<	assertEquals(l.get(j), j);
717	<	}
842	<	while (q.poll() != null)
843	<	;
713	>	assertEquals(k, l.size());
714	>	assertEquals(SIZE - k, q.size());
715	>	for (int j = 0; j < k; ++j)
716	>	assertEquals(j, l.get(j));
717	>	do {} while (q.poll() != null);
718		}
719		}
720
#	Line 850 | Line 724 | public class LinkedTransferQueueTest ext
724		*/
725		public void testWaitingConsumer() throws InterruptedException {
726		final LinkedTransferQueue q = new LinkedTransferQueue();
727	<	assertEquals(q.getWaitingConsumerCount(), 0);
727	>	assertEquals(0, q.getWaitingConsumerCount());
728		assertFalse(q.hasWaitingConsumer());
729		final CountDownLatch threadStarted = new CountDownLatch(1);
730
731		Thread t = newStartedThread(new CheckedRunnable() {
732		public void realRun() throws InterruptedException {
733		threadStarted.countDown();
734	+	long startTime = System.nanoTime();
735		assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
736	<	assertEquals(q.getWaitingConsumerCount(), 0);
736	>	assertEquals(0, q.getWaitingConsumerCount());
737		assertFalse(q.hasWaitingConsumer());
738	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
739		}});
740
741		threadStarted.await();
742	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
743	<	assertEquals(q.getWaitingConsumerCount(), 1);
742	>	waitForThreadToEnterWaitState(t);
743	>	assertEquals(1, q.getWaitingConsumerCount());
744		assertTrue(q.hasWaitingConsumer());
745
746		assertTrue(q.offer(one));
747	<	assertEquals(q.getWaitingConsumerCount(), 0);
747	>	assertEquals(0, q.getWaitingConsumerCount());
748		assertFalse(q.hasWaitingConsumer());
749
750	<	awaitTermination(t, MEDIUM_DELAY_MS);
750	>	awaitTermination(t);
751		}
752
753		/**
#	Line 887 | Line 763 | public class LinkedTransferQueueTest ext
763
764		/**
765		* transfer waits until a poll occurs. The transfered element
766	<	* is returned by this associated poll.
766	>	* is returned by the associated poll.
767		*/
768		public void testTransfer2() throws InterruptedException {
769	<	final LinkedTransferQueue<Integer> q
894	<	= new LinkedTransferQueue<Integer>();
769	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
770		final CountDownLatch threadStarted = new CountDownLatch(1);
771
772		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 902 | Line 777 | public class LinkedTransferQueueTest ext
777		}});
778
779		threadStarted.await();
780	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
780	>	waitForThreadToEnterWaitState(t);
781		assertEquals(1, q.size());
782		assertSame(five, q.poll());
783		checkEmpty(q);
784	<	awaitTermination(t, MEDIUM_DELAY_MS);
784	>	awaitTermination(t);
785		}
786
787		/**
788		* transfer waits until a poll occurs, and then transfers in fifo order
789		*/
790		public void testTransfer3() throws InterruptedException {
791	<	final LinkedTransferQueue<Integer> q
917	<	= new LinkedTransferQueue<Integer>();
791	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
792
793		Thread first = newStartedThread(new CheckedRunnable() {
794		public void realRun() throws InterruptedException {
#	Line 962 | Line 836 | public class LinkedTransferQueueTest ext
836		assertEquals(1, q.size());
837		assertTrue(q.offer(three));
838		assertSame(four, q.poll());
839	<	awaitTermination(t, MEDIUM_DELAY_MS);
839	>	awaitTermination(t);
840		}
841
842		/**
843		* transfer waits until a take occurs. The transfered element
844	<	* is returned by this associated take.
844	>	* is returned by the associated take.
845		*/
846		public void testTransfer5() throws InterruptedException {
847	<	final LinkedTransferQueue<Integer> q
974	<	= new LinkedTransferQueue<Integer>();
847	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
848
849		Thread t = newStartedThread(new CheckedRunnable() {
850		public void realRun() throws InterruptedException {
#	Line 985 | Line 858 | public class LinkedTransferQueueTest ext
858		assertEquals(1, q.size());
859		assertSame(four, q.take());
860		checkEmpty(q);
861	<	awaitTermination(t, MEDIUM_DELAY_MS);
861	>	awaitTermination(t);
862		}
863
864		/**
865		* tryTransfer(null) throws NullPointerException
866		*/
867		public void testTryTransfer1() {
868	+	final LinkedTransferQueue q = new LinkedTransferQueue();
869		try {
996	–	final LinkedTransferQueue q = new LinkedTransferQueue();
870		q.tryTransfer(null);
871		shouldThrow();
872		} catch (NullPointerException success) {}
#	Line 1027 | Line 900 | public class LinkedTransferQueueTest ext
900		assertTrue(q.tryTransfer(hotPotato));
901		}});
902
903	<	assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
903	>	long startTime = System.nanoTime();
904	>	assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
905	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
906		checkEmpty(q);
907	<	awaitTermination(t, MEDIUM_DELAY_MS);
907	>	awaitTermination(t);
908		}
909
910		/**
#	Line 1051 | Line 926 | public class LinkedTransferQueueTest ext
926
927		assertSame(q.take(), hotPotato);
928		checkEmpty(q);
929	<	awaitTermination(t, MEDIUM_DELAY_MS);
929	>	awaitTermination(t);
930		}
931
932		/**
#	Line 1064 | Line 939 | public class LinkedTransferQueueTest ext
939
940		Thread t = newStartedThread(new CheckedRunnable() {
941		public void realRun() throws InterruptedException {
942	+	long startTime = System.nanoTime();
943		Thread.currentThread().interrupt();
944		try {
945		q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
#	Line 1077 | Line 953 | public class LinkedTransferQueueTest ext
953		shouldThrow();
954		} catch (InterruptedException success) {}
955		assertFalse(Thread.interrupted());
956	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
957		}});
958
959		await(pleaseInterrupt);
#	Line 1094 | Line 971 | public class LinkedTransferQueueTest ext
971
972		Thread t = newStartedThread(new CheckedRunnable() {
973		public void realRun() throws InterruptedException {
974	<	long t0 = System.nanoTime();
974	>	long startTime = System.nanoTime();
975		assertFalse(q.tryTransfer(new Object(),
976		timeoutMillis(), MILLISECONDS));
977	<	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
977	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
978		checkEmpty(q);
979		}});
980
#	Line 1115 | Line 992 | public class LinkedTransferQueueTest ext
992
993		Thread t = newStartedThread(new CheckedRunnable() {
994		public void realRun() throws InterruptedException {
995	<	assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
995	>	long startTime = System.nanoTime();
996	>	assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
997	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
998		checkEmpty(q);
999		}});
1000
#	Line 1125 | Line 1004 | public class LinkedTransferQueueTest ext
1004		assertSame(four, q.poll());
1005		assertSame(five, q.poll());
1006		checkEmpty(q);
1007	<	awaitTermination(t, MEDIUM_DELAY_MS);
1007	>	awaitTermination(t);
1008		}
1009
1010		/**
#	Line 1136 | Line 1015 | public class LinkedTransferQueueTest ext
1015		final LinkedTransferQueue q = new LinkedTransferQueue();
1016		assertTrue(q.offer(four));
1017		assertEquals(1, q.size());
1018	<	long t0 = System.nanoTime();
1018	>	long startTime = System.nanoTime();
1019		assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1020	<	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1020	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1021		assertEquals(1, q.size());
1022		assertSame(four, q.poll());
1023		assertNull(q.poll());
#	Line 1146 | Line 1025 | public class LinkedTransferQueueTest ext
1025		}
1026
1027		private LinkedTransferQueue<Integer> populatedQueue(int n) {
1028	<	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1028	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1029		checkEmpty(q);
1030		for (int i = 0; i < n; i++) {
1031		assertEquals(i, q.size());
#	Line 1156 | Line 1035 | public class LinkedTransferQueueTest ext
1035		assertFalse(q.isEmpty());
1036		return q;
1037		}
1038	+
1039	+	/**
1040	+	* remove(null), contains(null) always return false
1041	+	*/
1042	+	public void testNeverContainsNull() {
1043	+	Collection<?>[] qs = {
1044	+	new LinkedTransferQueue<Object>(),
1045	+	populatedQueue(2),
1046	+	};
1047	+
1048	+	for (Collection<?> q : qs) {
1049	+	assertFalse(q.contains(null));
1050	+	assertFalse(q.remove(null));
1051	+	}
1052	+	}
1053		}

Diff Legend

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