[ViewVC] Diff of: jsr166/jsr166/src/test/tck/LinkedTransferQueueTest.java

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.60 by jsr166, Fri May 15 18:21:19 2015 UTC vs.
Revision 1.67 by jsr166, Sun Oct 16 20:16:36 2016 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 36 \| Line 35 \| public class LinkedTransferQueueTest ext
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 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 588 \| 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	<
593	<	executor.execute(new CheckedRunnable() {
594	<	public void realRun() throws InterruptedException {
595	<	threadsStarted.await();
596	<	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
597	<	}});
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 612 \| 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);
620	<
617	<	executor.execute(new CheckedRunnable() {
618	<	public void realRun() throws InterruptedException {
619	<	assertNull(q.poll());
620	<	threadsStarted.await();
621	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
622	<	checkEmpty(q);
623	<	}});
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	<	threadsStarted.await();
625	<	q.put(one);
626	<	}});
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 689 \| 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 726 \| 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 740 \| 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 771 \| 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 831 \| 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 854 \| 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		/**
#	Line 896 \| 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 920 \| 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 933 \| 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 946 \| 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 963 \| 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 984 \| 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 994 \| 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 1005 \| 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

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents): Revision 1.60 by jsr166, Fri May 15 18:21:19 2015 UTC vs. Revision 1.67 by jsr166, Sun Oct 16 20:16:36 2016 UTC

Diff Legend

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.60 by jsr166, Fri May 15 18:21:19 2015 UTC vs.
Revision 1.67 by jsr166, Sun Oct 16 20:16:36 2016 UTC