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.58 by jsr166, Sat Feb 28 19:59:23 2015 UTC vs.
Revision 1.68 by jsr166, Wed Jan 4 06:09:58 2017 UTC

#	Line 24 | Line 24 | import junit.framework.Test;
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 78 | 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 132 | Line 139 | public class LinkedTransferQueueTest ext
139		* addAll(this) throws IllegalArgumentException
140		*/
141		public void testAddAllSelf() {
142	+	LinkedTransferQueue q = populatedQueue(SIZE);
143		try {
136	–	LinkedTransferQueue q = populatedQueue(SIZE);
144		q.addAll(q);
145		shouldThrow();
146		} catch (IllegalArgumentException success) {}
#	Line 144 | 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 {
148	–	LinkedTransferQueue q = new LinkedTransferQueue();
149	–	Integer[] ints = new Integer[SIZE];
150	–	for (int i = 0; i < SIZE - 1; ++i) {
151	–	ints[i] = i;
152	–	}
159		q.addAll(Arrays.asList(ints));
160		shouldThrow();
161		} catch (NullPointerException success) {}
#	Line 176 | 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(i, q.size());
188		q.put(i);
#	Line 256 | Line 262 | public class LinkedTransferQueueTest ext
262		*/
263		public void testTimedPoll() throws InterruptedException {
264		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
259	–	for (int i = 0; i < SIZE; ++i) {
260	–	long startTime = System.nanoTime();
261	–	assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
262	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
263	–	}
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 276 | 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));
282	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
283	–	}
284	–	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);
291	<	}
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 306 | 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) {
311	<	long t0 = System.nanoTime();
313	>	for (int i = 0; i < SIZE; ++i)
314		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
313	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
314	–	}
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 414 | 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 543 | Line 544 | public class LinkedTransferQueueTest ext
544		* iterator ordering is FIFO
545		*/
546		public void testIteratorOrdering() {
547	<	final LinkedTransferQueue<Integer> q
547	<	= 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 589 | 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	<
594	<	executor.execute(new CheckedRunnable() {
595	<	public void realRun() throws InterruptedException {
596	<	threadsStarted.await();
597	<	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
598	<	}});
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 613 | 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() {
627	<	public void realRun() throws InterruptedException {
628	<	threadsStarted.await();
629	<	q.put(one);
630	<	}});
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 690 | Line 694 | public class LinkedTransferQueueTest ext
694		assertTrue(l.size() >= SIZE);
695		for (int i = 0; i < SIZE; ++i)
696		assertEquals(i, l.get(i));
697	<	awaitTermination(t, MEDIUM_DELAY_MS);
697	>	awaitTermination(t);
698		assertTrue(q.size() + l.size() >= SIZE);
699		}
700
#	Line 727 | 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 741 | 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 760 | 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
764	<	= 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 772 | 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
787	<	= new LinkedTransferQueue<Integer>();
791	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
792
793		Thread first = newStartedThread(new CheckedRunnable() {
794		public void realRun() throws InterruptedException {
#	Line 832 | 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 840 | 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
844	<	= new LinkedTransferQueue<Integer>();
847	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
848
849		Thread t = newStartedThread(new CheckedRunnable() {
850		public void realRun() throws InterruptedException {
#	Line 855 | 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 {
866	–	final LinkedTransferQueue q = new LinkedTransferQueue();
870		q.tryTransfer(null);
871		shouldThrow();
872		} catch (NullPointerException success) {}
#	Line 897 | 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 921 | 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 934 | 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 947 | 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 964 | 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 985 | 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 995 | 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 1006 | 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 1016 | 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());

Diff Legend

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