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.54 by jsr166, Wed Dec 31 16:44:02 2014 UTC vs.
Revision 1.67 by jsr166, Sun Oct 16 20:16:36 2016 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;
22	>
23	>	import junit.framework.Test;
24
25		@SuppressWarnings({"unchecked", "rawtypes"})
26		public class LinkedTransferQueueTest extends JSR166TestCase {
25	–
27		public static class Generic extends BlockingQueueTest {
28		protected BlockingQueue emptyCollection() {
29		return new LinkedTransferQueue();
#	Line 30 | 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 76 | 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 113 | 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 130 | Line 139 | public class LinkedTransferQueueTest ext
139		* addAll(this) throws IllegalArgumentException
140		*/
141		public void testAddAllSelf() {
142	+	LinkedTransferQueue q = populatedQueue(SIZE);
143		try {
134	–	LinkedTransferQueue q = populatedQueue(SIZE);
144		q.addAll(q);
145		shouldThrow();
146		} catch (IllegalArgumentException success) {}
#	Line 142 | 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 {
146	–	LinkedTransferQueue q = new LinkedTransferQueue();
147	–	Integer[] ints = new Integer[SIZE];
148	–	for (int i = 0; i < SIZE - 1; ++i) {
149	–	ints[i] = i;
150	–	}
159		q.addAll(Arrays.asList(ints));
160		shouldThrow();
161		} catch (NullPointerException success) {}
#	Line 254 | Line 262 | public class LinkedTransferQueueTest ext
262		*/
263		public void testTimedPoll() throws InterruptedException {
264		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
257	–	for (int i = 0; i < SIZE; ++i) {
258	–	long startTime = System.nanoTime();
259	–	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
260	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
261	–	}
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 274 | 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));
280	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
281	–	}
282	–	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);
289	<	}
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 304 | 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) {
309	<	long t0 = System.nanoTime();
313	>	for (int i = 0; i < SIZE; ++i)
314		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
311	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
312	–	}
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 498 | 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++);
504	<	}
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 574 | Line 590 | public class LinkedTransferQueueTest ext
590		public void testOfferInExecutor() {
591		final LinkedTransferQueue q = new LinkedTransferQueue();
592		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
593	<	ExecutorService executor = Executors.newFixedThreadPool(2);
594	<
579	<	executor.execute(new CheckedRunnable() {
580	<	public void realRun() throws InterruptedException {
581	<	threadsStarted.await();
582	<	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
583	<	}});
593	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
594	>	try (PoolCleaner cleaner = cleaner(executor)) {
595
596	<	executor.execute(new CheckedRunnable() {
597	<	public void realRun() throws InterruptedException {
598	<	threadsStarted.await();
599	<	assertSame(one, q.take());
600	<	checkEmpty(q);
601	<	}});
596	>	executor.execute(new CheckedRunnable() {
597	>	public void realRun() throws InterruptedException {
598	>	threadsStarted.await();
599	>	long startTime = System.nanoTime();
600	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
601	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
602	>	}});
603
604	<	joinPool(executor);
604	>	executor.execute(new CheckedRunnable() {
605	>	public void realRun() throws InterruptedException {
606	>	threadsStarted.await();
607	>	assertSame(one, q.take());
608	>	checkEmpty(q);
609	>	}});
610	>	}
611		}
612
613		/**
#	Line 598 | Line 616 | public class LinkedTransferQueueTest ext
616		public void testPollInExecutor() {
617		final LinkedTransferQueue q = new LinkedTransferQueue();
618		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
619	<	ExecutorService executor = Executors.newFixedThreadPool(2);
619	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
620	>	try (PoolCleaner cleaner = cleaner(executor)) {
621
622	<	executor.execute(new CheckedRunnable() {
623	<	public void realRun() throws InterruptedException {
624	<	assertNull(q.poll());
625	<	threadsStarted.await();
626	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
627	<	checkEmpty(q);
628	<	}});
629	<
630	<	executor.execute(new CheckedRunnable() {
612	<	public void realRun() throws InterruptedException {
613	<	threadsStarted.await();
614	<	q.put(one);
615	<	}});
622	>	executor.execute(new CheckedRunnable() {
623	>	public void realRun() throws InterruptedException {
624	>	assertNull(q.poll());
625	>	threadsStarted.await();
626	>	long startTime = System.nanoTime();
627	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
628	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
629	>	checkEmpty(q);
630	>	}});
631
632	<	joinPool(executor);
632	>	executor.execute(new CheckedRunnable() {
633	>	public void realRun() throws InterruptedException {
634	>	threadsStarted.await();
635	>	q.put(one);
636	>	}});
637	>	}
638		}
639
640		/**
#	Line 675 | Line 695 | public class LinkedTransferQueueTest ext
695		assertTrue(l.size() >= SIZE);
696		for (int i = 0; i < SIZE; ++i)
697		assertEquals(i, l.get(i));
698	<	awaitTermination(t, MEDIUM_DELAY_MS);
698	>	awaitTermination(t);
699		assertTrue(q.size() + l.size() >= SIZE);
700		}
701
#	Line 695 | Line 715 | public class LinkedTransferQueueTest ext
715		assertEquals(SIZE - k, q.size());
716		for (int j = 0; j < k; ++j)
717		assertEquals(j, l.get(j));
718	<	while (q.poll() != null)
699	<	;
718	>	do {} while (q.poll() != null);
719		}
720		}
721
#	Line 713 | Line 732 | public class LinkedTransferQueueTest ext
732		Thread t = newStartedThread(new CheckedRunnable() {
733		public void realRun() throws InterruptedException {
734		threadStarted.countDown();
735	+	long startTime = System.nanoTime();
736		assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
737		assertEquals(0, q.getWaitingConsumerCount());
738		assertFalse(q.hasWaitingConsumer());
739	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
740		}});
741
742		threadStarted.await();
743	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
743	>	waitForThreadToEnterWaitState(t);
744		assertEquals(1, q.getWaitingConsumerCount());
745		assertTrue(q.hasWaitingConsumer());
746
#	Line 727 | Line 748 | public class LinkedTransferQueueTest ext
748		assertEquals(0, q.getWaitingConsumerCount());
749		assertFalse(q.hasWaitingConsumer());
750
751	<	awaitTermination(t, MEDIUM_DELAY_MS);
751	>	awaitTermination(t);
752		}
753
754		/**
#	Line 758 | Line 779 | public class LinkedTransferQueueTest ext
779		}});
780
781		threadStarted.await();
782	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
782	>	waitForThreadToEnterWaitState(t);
783		assertEquals(1, q.size());
784		assertSame(five, q.poll());
785		checkEmpty(q);
786	<	awaitTermination(t, MEDIUM_DELAY_MS);
786	>	awaitTermination(t);
787		}
788
789		/**
#	Line 818 | Line 839 | public class LinkedTransferQueueTest ext
839		assertEquals(1, q.size());
840		assertTrue(q.offer(three));
841		assertSame(four, q.poll());
842	<	awaitTermination(t, MEDIUM_DELAY_MS);
842	>	awaitTermination(t);
843		}
844
845		/**
#	Line 841 | Line 862 | public class LinkedTransferQueueTest ext
862		assertEquals(1, q.size());
863		assertSame(four, q.take());
864		checkEmpty(q);
865	<	awaitTermination(t, MEDIUM_DELAY_MS);
865	>	awaitTermination(t);
866		}
867
868		/**
869		* tryTransfer(null) throws NullPointerException
870		*/
871		public void testTryTransfer1() {
872	+	final LinkedTransferQueue q = new LinkedTransferQueue();
873		try {
852	–	final LinkedTransferQueue q = new LinkedTransferQueue();
874		q.tryTransfer(null);
875		shouldThrow();
876		} catch (NullPointerException success) {}
#	Line 883 | Line 904 | public class LinkedTransferQueueTest ext
904		assertTrue(q.tryTransfer(hotPotato));
905		}});
906
907	<	assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
907	>	long startTime = System.nanoTime();
908	>	assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
909	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
910		checkEmpty(q);
911	<	awaitTermination(t, MEDIUM_DELAY_MS);
911	>	awaitTermination(t);
912		}
913
914		/**
#	Line 907 | Line 930 | public class LinkedTransferQueueTest ext
930
931		assertSame(q.take(), hotPotato);
932		checkEmpty(q);
933	<	awaitTermination(t, MEDIUM_DELAY_MS);
933	>	awaitTermination(t);
934		}
935
936		/**
#	Line 920 | Line 943 | public class LinkedTransferQueueTest ext
943
944		Thread t = newStartedThread(new CheckedRunnable() {
945		public void realRun() throws InterruptedException {
946	+	long startTime = System.nanoTime();
947		Thread.currentThread().interrupt();
948		try {
949		q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
#	Line 933 | Line 957 | public class LinkedTransferQueueTest ext
957		shouldThrow();
958		} catch (InterruptedException success) {}
959		assertFalse(Thread.interrupted());
960	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
961		}});
962
963		await(pleaseInterrupt);
#	Line 950 | Line 975 | public class LinkedTransferQueueTest ext
975
976		Thread t = newStartedThread(new CheckedRunnable() {
977		public void realRun() throws InterruptedException {
978	<	long t0 = System.nanoTime();
978	>	long startTime = System.nanoTime();
979		assertFalse(q.tryTransfer(new Object(),
980		timeoutMillis(), MILLISECONDS));
981	<	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
981	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
982		checkEmpty(q);
983		}});
984
#	Line 971 | Line 996 | public class LinkedTransferQueueTest ext
996
997		Thread t = newStartedThread(new CheckedRunnable() {
998		public void realRun() throws InterruptedException {
999	<	assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
999	>	long startTime = System.nanoTime();
1000	>	assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
1001	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1002		checkEmpty(q);
1003		}});
1004
#	Line 981 | Line 1008 | public class LinkedTransferQueueTest ext
1008		assertSame(four, q.poll());
1009		assertSame(five, q.poll());
1010		checkEmpty(q);
1011	<	awaitTermination(t, MEDIUM_DELAY_MS);
1011	>	awaitTermination(t);
1012		}
1013
1014		/**
#	Line 992 | Line 1019 | public class LinkedTransferQueueTest ext
1019		final LinkedTransferQueue q = new LinkedTransferQueue();
1020		assertTrue(q.offer(four));
1021		assertEquals(1, q.size());
1022	<	long t0 = System.nanoTime();
1022	>	long startTime = System.nanoTime();
1023		assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1024	<	assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1024	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1025		assertEquals(1, q.size());
1026		assertSame(four, q.poll());
1027		assertNull(q.poll());

Diff Legend

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