ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/LinkedBlockingDequeTest.java

Comparing jsr166/src/test/tck/LinkedBlockingDequeTest.java (file contents):
Revision 1.65 by jsr166, Sun Oct 16 20:44:18 2016 UTC vs.
Revision 1.72 by jsr166, Sat May 13 22:17:12 2017 UTC

#	Line 41 | Line 41 | public class LinkedBlockingDequeTest ext
41		}
42
43		public static Test suite() {
44	+	class Implementation implements CollectionImplementation {
45	+	public Class<?> klazz() { return LinkedBlockingDeque.class; }
46	+	public Collection emptyCollection() { return new LinkedBlockingDeque(); }
47	+	public Object makeElement(int i) { return i; }
48	+	public boolean isConcurrent() { return true; }
49	+	public boolean permitsNulls() { return false; }
50	+	}
51		return newTestSuite(LinkedBlockingDequeTest.class,
52		new Unbounded().testSuite(),
53	<	new Bounded().testSuite());
53	>	new Bounded().testSuite(),
54	>	CollectionTest.testSuite(new Implementation()));
55		}
56
57		/**
58		* Returns a new deque of given size containing consecutive
59		* Integers 0 ... n - 1.
60		*/
61	<	private LinkedBlockingDeque<Integer> populatedDeque(int n) {
61	>	private static LinkedBlockingDeque<Integer> populatedDeque(int n) {
62		LinkedBlockingDeque<Integer> q =
63		new LinkedBlockingDeque<Integer>(n);
64		assertTrue(q.isEmpty());
#	Line 596 | Line 604 | public class LinkedBlockingDequeTest ext
604		}});
605
606		await(pleaseInterrupt);
607	<	assertThreadStaysAlive(t);
607	>	assertThreadBlocks(t, Thread.State.WAITING);
608		t.interrupt();
609		awaitTermination(t);
610		assertEquals(SIZE, q.size());
#	Line 631 | Line 639 | public class LinkedBlockingDequeTest ext
639		assertEquals(0, q.take());
640
641		await(pleaseInterrupt);
642	<	assertThreadStaysAlive(t);
642	>	assertThreadBlocks(t, Thread.State.WAITING);
643		t.interrupt();
644		awaitTermination(t);
645		assertEquals(0, q.remainingCapacity());
#	Line 658 | Line 666 | public class LinkedBlockingDequeTest ext
666		}});
667
668		await(pleaseInterrupt);
669	<	assertThreadStaysAlive(t);
669	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
670		t.interrupt();
671		awaitTermination(t);
672		}
#	Line 681 | Line 689 | public class LinkedBlockingDequeTest ext
689		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
690		Thread t = newStartedThread(new CheckedRunnable() {
691		public void realRun() throws InterruptedException {
692	<	for (int i = 0; i < SIZE; ++i) {
685	<	assertEquals(i, q.take());
686	<	}
692	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
693
694		Thread.currentThread().interrupt();
695		try {
#	Line 701 | Line 707 | public class LinkedBlockingDequeTest ext
707		}});
708
709		await(pleaseInterrupt);
710	<	assertThreadStaysAlive(t);
710	>	assertThreadBlocks(t, Thread.State.WAITING);
711		t.interrupt();
712		awaitTermination(t);
713		}
#	Line 766 | Line 772 | public class LinkedBlockingDequeTest ext
772		}
773		}});
774
775	<	aboutToWait.await();
775	>	await(aboutToWait);
776		waitForThreadToEnterWaitState(t);
777		t.interrupt();
778		awaitTermination(t);
#	Line 826 | Line 832 | public class LinkedBlockingDequeTest ext
832		}});
833
834		await(pleaseInterrupt);
835	<	assertThreadStaysAlive(t);
835	>	assertThreadBlocks(t, Thread.State.WAITING);
836		t.interrupt();
837		awaitTermination(t);
838		assertEquals(SIZE, q.size());
#	Line 861 | Line 867 | public class LinkedBlockingDequeTest ext
867		assertEquals(capacity - 1, q.take());
868
869		await(pleaseInterrupt);
870	<	assertThreadStaysAlive(t);
870	>	assertThreadBlocks(t, Thread.State.WAITING);
871		t.interrupt();
872		awaitTermination(t);
873		assertEquals(0, q.remainingCapacity());
#	Line 888 | Line 894 | public class LinkedBlockingDequeTest ext
894		}});
895
896		await(pleaseInterrupt);
897	<	assertThreadStaysAlive(t);
897	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
898		t.interrupt();
899		awaitTermination(t);
900		}
#	Line 920 | Line 926 | public class LinkedBlockingDequeTest ext
926		}});
927
928		await(threadStarted);
929	<	assertThreadStaysAlive(t);
929	>	assertThreadBlocks(t, Thread.State.WAITING);
930		t.interrupt();
931		awaitTermination(t);
932		}
#	Line 961 | Line 967 | public class LinkedBlockingDequeTest ext
967		}});
968
969		await(threadStarted);
970	<	assertThreadStaysAlive(t);
970	>	assertThreadBlocks(t, Thread.State.WAITING);
971		t.interrupt();
972		awaitTermination(t);
973		}
#	Line 993 | Line 999 | public class LinkedBlockingDequeTest ext
999		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1000		Thread t = newStartedThread(new CheckedRunnable() {
1001		public void realRun() throws InterruptedException {
1002	<	for (int i = 0; i < SIZE; ++i) {
997	<	assertEquals(i, q.takeFirst());
998	<	}
1002	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.takeFirst());
1003
1004		Thread.currentThread().interrupt();
1005		try {
#	Line 1013 | Line 1017 | public class LinkedBlockingDequeTest ext
1017		}});
1018
1019		await(pleaseInterrupt);
1020	<	assertThreadStaysAlive(t);
1020	>	assertThreadBlocks(t, Thread.State.WAITING);
1021		t.interrupt();
1022		awaitTermination(t);
1023		}
#	Line 1175 | Line 1179 | public class LinkedBlockingDequeTest ext
1179		}});
1180
1181		await(pleaseInterrupt);
1182	<	assertThreadStaysAlive(t);
1182	>	assertThreadBlocks(t, Thread.State.WAITING);
1183		t.interrupt();
1184		awaitTermination(t);
1185		assertEquals(SIZE, q.size());
#	Line 1210 | Line 1214 | public class LinkedBlockingDequeTest ext
1214		assertEquals(0, q.take());
1215
1216		await(pleaseInterrupt);
1217	<	assertThreadStaysAlive(t);
1217	>	assertThreadBlocks(t, Thread.State.WAITING);
1218		t.interrupt();
1219		awaitTermination(t);
1220		assertEquals(0, q.remainingCapacity());
#	Line 1237 | Line 1241 | public class LinkedBlockingDequeTest ext
1241		}});
1242
1243		await(pleaseInterrupt);
1244	<	assertThreadStaysAlive(t);
1244	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1245		t.interrupt();
1246		awaitTermination(t);
1247		}
#	Line 1260 | Line 1264 | public class LinkedBlockingDequeTest ext
1264		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1265		Thread t = newStartedThread(new CheckedRunnable() {
1266		public void realRun() throws InterruptedException {
1267	<	for (int i = 0; i < SIZE; ++i) {
1267	>	for (int i = 0; i < SIZE; i++)
1268		assertEquals(SIZE - i - 1, q.takeLast());
1265	–	}
1269
1270		Thread.currentThread().interrupt();
1271		try {
#	Line 1280 | Line 1283 | public class LinkedBlockingDequeTest ext
1283		}});
1284
1285		await(pleaseInterrupt);
1286	<	assertThreadStaysAlive(t);
1286	>	assertThreadBlocks(t, Thread.State.WAITING);
1287		t.interrupt();
1288		awaitTermination(t);
1289		}

Diff Legend

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