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.72 by jsr166, Sat Mar 25 21:41:10 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 293 | Line 294 | public class LinkedTransferQueueTest ext
294		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
295		}});
296
297	<	aboutToWait.await();
297	>	await(aboutToWait);
298		waitForThreadToEnterWaitState(t);
299		t.interrupt();
300		awaitTermination(t);
#	Line 415 | Line 416 | public class LinkedTransferQueueTest ext
416		*/
417		public void testContainsAll() {
418		LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
419	<	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
419	>	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
420		for (int i = 0; i < SIZE; ++i) {
421		assertTrue(q.containsAll(p));
422		assertFalse(p.containsAll(q));
#	Line 544 | Line 545 | public class LinkedTransferQueueTest ext
545		* iterator ordering is FIFO
546		*/
547		public void testIteratorOrdering() {
548	<	final LinkedTransferQueue<Integer> q
548	<	= new LinkedTransferQueue<Integer>();
548	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
549		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
550		q.add(one);
551		q.add(two);
#	Line 740 | Line 740 | public class LinkedTransferQueueTest ext
740		}});
741
742		threadStarted.await();
743	<	waitForThreadToEnterWaitState(t);
744	<	assertEquals(1, q.getWaitingConsumerCount());
745	<	assertTrue(q.hasWaitingConsumer());
743	>	Callable<Boolean> oneConsumer
744	>	= new Callable<Boolean>() { public Boolean call() {
745	>	return q.hasWaitingConsumer()
746	>	&& q.getWaitingConsumerCount() == 1; }};
747	>	waitForThreadToEnterWaitState(t, oneConsumer);
748
749		assertTrue(q.offer(one));
750		assertEquals(0, q.getWaitingConsumerCount());
#	Line 764 | Line 766 | public class LinkedTransferQueueTest ext
766
767		/**
768		* transfer waits until a poll occurs. The transfered element
769	<	* is returned by this associated poll.
769	>	* is returned by the associated poll.
770		*/
771		public void testTransfer2() throws InterruptedException {
772	<	final LinkedTransferQueue<Integer> q
771	<	= new LinkedTransferQueue<Integer>();
772	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
773		final CountDownLatch threadStarted = new CountDownLatch(1);
774
775		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 779 | Line 780 | public class LinkedTransferQueueTest ext
780		}});
781
782		threadStarted.await();
783	<	waitForThreadToEnterWaitState(t);
784	<	assertEquals(1, q.size());
783	>	Callable<Boolean> oneElement
784	>	= new Callable<Boolean>() { public Boolean call() {
785	>	return !q.isEmpty() && q.size() == 1; }};
786	>	waitForThreadToEnterWaitState(t, oneElement);
787	>
788		assertSame(five, q.poll());
789		checkEmpty(q);
790		awaitTermination(t);
#	Line 790 | Line 794 | public class LinkedTransferQueueTest ext
794		* transfer waits until a poll occurs, and then transfers in fifo order
795		*/
796		public void testTransfer3() throws InterruptedException {
797	<	final LinkedTransferQueue<Integer> q
794	<	= new LinkedTransferQueue<Integer>();
797	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
798
799		Thread first = newStartedThread(new CheckedRunnable() {
800		public void realRun() throws InterruptedException {
801		q.transfer(four);
802	<	assertTrue(!q.contains(four));
802	>	assertFalse(q.contains(four));
803		assertEquals(1, q.size());
804		}});
805
#	Line 844 | Line 847 | public class LinkedTransferQueueTest ext
847
848		/**
849		* transfer waits until a take occurs. The transfered element
850	<	* is returned by this associated take.
850	>	* is returned by the associated take.
851		*/
852		public void testTransfer5() throws InterruptedException {
853	<	final LinkedTransferQueue<Integer> q
851	<	= new LinkedTransferQueue<Integer>();
853	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
854
855		Thread t = newStartedThread(new CheckedRunnable() {
856		public void realRun() throws InterruptedException {
#	Line 1029 | Line 1031 | public class LinkedTransferQueueTest ext
1031		}
1032
1033		private LinkedTransferQueue<Integer> populatedQueue(int n) {
1034	<	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1034	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1035		checkEmpty(q);
1036		for (int i = 0; i < n; i++) {
1037		assertEquals(i, q.size());

Diff Legend

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