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.67 by jsr166, Sun Oct 16 20:16:36 2016 UTC vs.
Revision 1.73 by jsr166, Sat May 13 21:43:51 2017 UTC

#	Line 15 | Line 15 | import java.util.List;
15		import java.util.NoSuchElementException;
16		import java.util.Queue;
17		import java.util.concurrent.BlockingQueue;
18	+	import java.util.concurrent.Callable;
19		import java.util.concurrent.CountDownLatch;
20		import java.util.concurrent.Executors;
21		import java.util.concurrent.ExecutorService;
#	Line 182 | Line 183 | public class LinkedTransferQueueTest ext
183		* all elements successfully put are contained
184		*/
185		public void testPut() {
186	<	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
186	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
187		for (int i = 0; i < SIZE; ++i) {
188		assertEquals(i, q.size());
189		q.put(i);
#	Line 208 | Line 209 | public class LinkedTransferQueueTest ext
209		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
210		Thread t = newStartedThread(new CheckedRunnable() {
211		public void realRun() throws InterruptedException {
212	<	for (int i = 0; i < SIZE; ++i) {
212	<	assertEquals(i, q.take());
213	<	}
212	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
213
214		Thread.currentThread().interrupt();
215		try {
#	Line 228 | Line 227 | public class LinkedTransferQueueTest ext
227		}});
228
229		await(pleaseInterrupt);
230	<	assertThreadStaysAlive(t);
230	>	assertThreadBlocks(t, Thread.State.WAITING);
231		t.interrupt();
232		awaitTermination(t);
233		}
#	Line 293 | Line 292 | public class LinkedTransferQueueTest ext
292		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
293		}});
294
295	<	aboutToWait.await();
295	>	await(aboutToWait);
296		waitForThreadToEnterWaitState(t);
297		t.interrupt();
298		awaitTermination(t);
#	Line 415 | Line 414 | public class LinkedTransferQueueTest ext
414		*/
415		public void testContainsAll() {
416		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
417	<	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
417	>	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
418		for (int i = 0; i < SIZE; ++i) {
419		assertTrue(q.containsAll(p));
420		assertFalse(p.containsAll(q));
#	Line 544 | Line 543 | public class LinkedTransferQueueTest ext
543		* iterator ordering is FIFO
544		*/
545		public void testIteratorOrdering() {
546	<	final LinkedTransferQueue<Integer> q
548	<	= new LinkedTransferQueue<Integer>();
546	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
547		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
548		q.add(one);
549		q.add(two);
#	Line 740 | Line 738 | public class LinkedTransferQueueTest ext
738		}});
739
740		threadStarted.await();
741	<	waitForThreadToEnterWaitState(t);
742	<	assertEquals(1, q.getWaitingConsumerCount());
743	<	assertTrue(q.hasWaitingConsumer());
741	>	Callable<Boolean> oneConsumer
742	>	= new Callable<Boolean>() { public Boolean call() {
743	>	return q.hasWaitingConsumer()
744	>	&& q.getWaitingConsumerCount() == 1; }};
745	>	waitForThreadToEnterWaitState(t, oneConsumer);
746
747		assertTrue(q.offer(one));
748		assertEquals(0, q.getWaitingConsumerCount());
#	Line 764 | Line 764 | public class LinkedTransferQueueTest ext
764
765		/**
766		* transfer waits until a poll occurs. The transfered element
767	<	* is returned by this associated poll.
767	>	* is returned by the associated poll.
768		*/
769		public void testTransfer2() throws InterruptedException {
770	<	final LinkedTransferQueue<Integer> q
771	<	= new LinkedTransferQueue<Integer>();
770	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
771		final CountDownLatch threadStarted = new CountDownLatch(1);
772
773		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 779 | Line 778 | public class LinkedTransferQueueTest ext
778		}});
779
780		threadStarted.await();
781	<	waitForThreadToEnterWaitState(t);
782	<	assertEquals(1, q.size());
781	>	Callable<Boolean> oneElement
782	>	= new Callable<Boolean>() { public Boolean call() {
783	>	return !q.isEmpty() && q.size() == 1; }};
784	>	waitForThreadToEnterWaitState(t, oneElement);
785	>
786		assertSame(five, q.poll());
787		checkEmpty(q);
788		awaitTermination(t);
#	Line 790 | Line 792 | public class LinkedTransferQueueTest ext
792		* transfer waits until a poll occurs, and then transfers in fifo order
793		*/
794		public void testTransfer3() throws InterruptedException {
795	<	final LinkedTransferQueue<Integer> q
794	<	= new LinkedTransferQueue<Integer>();
795	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
796
797		Thread first = newStartedThread(new CheckedRunnable() {
798		public void realRun() throws InterruptedException {
799		q.transfer(four);
800	<	assertTrue(!q.contains(four));
800	>	assertFalse(q.contains(four));
801		assertEquals(1, q.size());
802		}});
803
#	Line 844 | Line 845 | public class LinkedTransferQueueTest ext
845
846		/**
847		* transfer waits until a take occurs. The transfered element
848	<	* is returned by this associated take.
848	>	* is returned by the associated take.
849		*/
850		public void testTransfer5() throws InterruptedException {
851	<	final LinkedTransferQueue<Integer> q
851	<	= new LinkedTransferQueue<Integer>();
851	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
852
853		Thread t = newStartedThread(new CheckedRunnable() {
854		public void realRun() throws InterruptedException {
#	Line 1029 | Line 1029 | public class LinkedTransferQueueTest ext
1029		}
1030
1031		private LinkedTransferQueue<Integer> populatedQueue(int n) {
1032	<	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1032	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1033		checkEmpty(q);
1034		for (int i = 0; i < n; i++) {
1035		assertEquals(i, q.size());

Diff Legend

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