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.50 by jsr166, Sat Nov 26 05:19:17 2011 UTC vs.
Revision 1.68 by jsr166, Wed Jan 4 06:09:58 2017 UTC

#	Line 5 | Line 5
5		* Other contributors include John Vint
6		*/
7
8	<	import junit.framework.*;
9	<	import java.util.Arrays;
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;
#	Line 18 | Line 19 | import java.util.concurrent.CountDownLat
19		import java.util.concurrent.Executors;
20		import java.util.concurrent.ExecutorService;
21		import java.util.concurrent.LinkedTransferQueue;
22	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
23	<	import static java.util.concurrent.TimeUnit.NANOSECONDS;
22	>
23	>	import junit.framework.Test;
24
25		@SuppressWarnings({"unchecked", "rawtypes"})
26		public class LinkedTransferQueueTest extends JSR166TestCase {
26	–
27		public static class Generic extends BlockingQueueTest {
28		protected BlockingQueue emptyCollection() {
29		return new LinkedTransferQueue();
#	Line 31 | 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 77 | Line 85 | public class LinkedTransferQueueTest ext
85		*/
86		public void testConstructor4() {
87		Integer[] ints = new Integer[SIZE];
88	<	for (int i = 0; i < SIZE-1; ++i)
88	>	for (int i = 0; i < SIZE - 1; ++i)
89		ints[i] = i;
90		Collection<Integer> elements = Arrays.asList(ints);
91		try {
#	Line 114 | 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
#	Line 131 | Line 139 | public class LinkedTransferQueueTest ext
139		* addAll(this) throws IllegalArgumentException
140		*/
141		public void testAddAllSelf() {
142	+	LinkedTransferQueue q = populatedQueue(SIZE);
143		try {
135	–	LinkedTransferQueue q = populatedQueue(SIZE);
144		q.addAll(q);
145		shouldThrow();
146		} catch (IllegalArgumentException success) {}
#	Line 143 | Line 151 | public class LinkedTransferQueueTest ext
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 {
147	–	LinkedTransferQueue q = new LinkedTransferQueue();
148	–	Integer[] ints = new Integer[SIZE];
149	–	for (int i = 0; i < SIZE - 1; ++i) {
150	–	ints[i] = i;
151	–	}
159		q.addAll(Arrays.asList(ints));
160		shouldThrow();
161		} catch (NullPointerException success) {}
#	Line 175 | Line 182 | public class LinkedTransferQueueTest ext
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 255 | Line 262 | public class LinkedTransferQueueTest ext
262		*/
263		public void testTimedPoll() throws InterruptedException {
264		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
258	–	for (int i = 0; i < SIZE; ++i) {
259	–	long startTime = System.nanoTime();
260	–	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
261	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
262	–	}
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 275 | 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));
281	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
282	–	}
283	–	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);
290	<	}
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 305 | 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) {
310	<	long t0 = System.nanoTime();
313	>	for (int i = 0; i < SIZE; ++i)
314		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
312	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
313	–	}
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 413 | 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 499 | 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++);
505	<	}
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 529 | Line 544 | public class LinkedTransferQueueTest ext
544		* iterator ordering is FIFO
545		*/
546		public void testIteratorOrdering() {
547	<	final LinkedTransferQueue<Integer> q
533	<	= 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 575 | 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);
593	<
580	<	executor.execute(new CheckedRunnable() {
581	<	public void realRun() throws InterruptedException {
582	<	threadsStarted.await();
583	<	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
584	<	}});
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	<	assertSame(one, q.take());
599	<	checkEmpty(q);
600	<	}});
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 599 | 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() {
613	<	public void realRun() throws InterruptedException {
614	<	threadsStarted.await();
615	<	q.put(one);
616	<	}});
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		/**
#	Line 625 | Line 643 | public class LinkedTransferQueueTest ext
643		Queue x = populatedQueue(SIZE);
644		Queue y = serialClone(x);
645
646	<	assertTrue(x != y);
646	>	assertNotSame(y, x);
647		assertEquals(x.size(), y.size());
648		assertEquals(x.toString(), y.toString());
649		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
#	Line 646 | Line 664 | public class LinkedTransferQueueTest ext
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 658 | Line 676 | public class LinkedTransferQueueTest ext
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 674 | 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	<	}
680	<	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
#	Line 693 | 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	<	}
701	<	while (q.poll() != null)
702	<	;
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 716 | Line 731 | public class LinkedTransferQueueTest ext
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(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);
742	>	waitForThreadToEnterWaitState(t);
743		assertEquals(1, q.getWaitingConsumerCount());
744		assertTrue(q.hasWaitingConsumer());
745
#	Line 730 | Line 747 | public class LinkedTransferQueueTest ext
747		assertEquals(0, q.getWaitingConsumerCount());
748		assertFalse(q.hasWaitingConsumer());
749
750	<	awaitTermination(t, MEDIUM_DELAY_MS);
750	>	awaitTermination(t);
751		}
752
753		/**
#	Line 749 | Line 766 | public class LinkedTransferQueueTest ext
766		* is returned by this associated poll.
767		*/
768		public void testTransfer2() throws InterruptedException {
769	<	final LinkedTransferQueue<Integer> q
753	<	= 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 761 | 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
776	<	= new LinkedTransferQueue<Integer>();
791	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
792
793		Thread first = newStartedThread(new CheckedRunnable() {
794		public void realRun() throws InterruptedException {
#	Line 821 | 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		/**
#	Line 829 | Line 844 | public class LinkedTransferQueueTest ext
844		* is returned by this associated take.
845		*/
846		public void testTransfer5() throws InterruptedException {
847	<	final LinkedTransferQueue<Integer> q
833	<	= new LinkedTransferQueue<Integer>();
847	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
848
849		Thread t = newStartedThread(new CheckedRunnable() {
850		public void realRun() throws InterruptedException {
#	Line 844 | 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 {
855	–	final LinkedTransferQueue q = new LinkedTransferQueue();
870		q.tryTransfer(null);
871		shouldThrow();
872		} catch (NullPointerException success) {}
#	Line 886 | 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 910 | 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 923 | 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 936 | 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 953 | 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 974 | 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 984 | 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 995 | 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 1005 | 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 1015 | 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