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.62 by jsr166, Tue Oct 6 00:03:55 2015 UTC vs.
Revision 1.86 by jsr166, Thu Sep 5 21:11:13 2019 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.
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 59 | Line 67 | public class LinkedBlockingDequeTest ext
67		assertFalse(q.isEmpty());
68		assertEquals(0, q.remainingCapacity());
69		assertEquals(n, q.size());
70	+	assertEquals((Integer) 0, q.peekFirst());
71	+	assertEquals((Integer) (n - 1), q.peekLast());
72		return q;
73		}
74
#	Line 432 | Line 442 | public class LinkedBlockingDequeTest ext
442		}
443
444		/**
445	<	* push succeeds if not full; throws ISE if full
445	>	* push succeeds if not full; throws IllegalStateException if full
446		*/
447		public void testPush() {
448		LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
#	Line 482 | Line 492 | public class LinkedBlockingDequeTest ext
492		}
493
494		/**
495	<	* add succeeds if not full; throws ISE if full
495	>	* add succeeds if not full; throws IllegalStateException if full
496		*/
497		public void testAdd() {
498		LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
#	Line 496 | Line 506 | public class LinkedBlockingDequeTest ext
506		}
507
508		/**
509	<	* addAll(this) throws IAE
509	>	* addAll(this) throws IllegalArgumentException
510		*/
511		public void testAddAllSelf() {
512		LinkedBlockingDeque q = populatedDeque(SIZE);
#	Line 594 | Line 604 | public class LinkedBlockingDequeTest ext
604		}});
605
606		await(pleaseInterrupt);
607	<	assertThreadStaysAlive(t);
607	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
608		t.interrupt();
609		awaitTermination(t);
610		assertEquals(SIZE, q.size());
#	Line 616 | Line 626 | public class LinkedBlockingDequeTest ext
626		pleaseTake.countDown();
627		q.put(86);
628
629	+	Thread.currentThread().interrupt();
630	+	try {
631	+	q.put(99);
632	+	shouldThrow();
633	+	} catch (InterruptedException success) {}
634	+	assertFalse(Thread.interrupted());
635	+
636		pleaseInterrupt.countDown();
637		try {
638		q.put(99);
#	Line 629 | Line 646 | public class LinkedBlockingDequeTest ext
646		assertEquals(0, q.take());
647
648		await(pleaseInterrupt);
649	<	assertThreadStaysAlive(t);
649	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
650		t.interrupt();
651		awaitTermination(t);
652		assertEquals(0, q.remainingCapacity());
#	Line 638 | Line 655 | public class LinkedBlockingDequeTest ext
655		/**
656		* timed offer times out if full and elements not taken
657		*/
658	<	public void testTimedOffer() throws InterruptedException {
658	>	public void testTimedOffer() {
659		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
660		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
661		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 646 | Line 663 | public class LinkedBlockingDequeTest ext
663		q.put(new Object());
664		q.put(new Object());
665		long startTime = System.nanoTime();
666	+
667		assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
668		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
669	+
670	+	Thread.currentThread().interrupt();
671	+	try {
672	+	q.offer(new Object(), randomTimeout(), randomTimeUnit());
673	+	shouldThrow();
674	+	} catch (InterruptedException success) {}
675	+	assertFalse(Thread.interrupted());
676	+
677		pleaseInterrupt.countDown();
678		try {
679	<	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
679	>	q.offer(new Object(), LONGER_DELAY_MS, MILLISECONDS);
680		shouldThrow();
681		} catch (InterruptedException success) {}
682	+	assertFalse(Thread.interrupted());
683		}});
684
685		await(pleaseInterrupt);
686	<	assertThreadStaysAlive(t);
686	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
687		t.interrupt();
688		awaitTermination(t);
689		}
#	Line 679 | Line 706 | public class LinkedBlockingDequeTest ext
706		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
707		Thread t = newStartedThread(new CheckedRunnable() {
708		public void realRun() throws InterruptedException {
709	<	for (int i = 0; i < SIZE; ++i) {
683	<	assertEquals(i, q.take());
684	<	}
709	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
710
711		Thread.currentThread().interrupt();
712		try {
#	Line 699 | Line 724 | public class LinkedBlockingDequeTest ext
724		}});
725
726		await(pleaseInterrupt);
727	<	assertThreadStaysAlive(t);
727	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
728		t.interrupt();
729		awaitTermination(t);
730		}
#	Line 748 | Line 773 | public class LinkedBlockingDequeTest ext
773		*/
774		public void testInterruptedTimedPoll() throws InterruptedException {
775		final BlockingQueue<Integer> q = populatedDeque(SIZE);
776	<	final CountDownLatch aboutToWait = new CountDownLatch(1);
776	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
777		Thread t = newStartedThread(new CheckedRunnable() {
778		public void realRun() throws InterruptedException {
779	<	long startTime = System.nanoTime();
755	<	for (int i = 0; i < SIZE; ++i) {
779	>	for (int i = 0; i < SIZE; i++)
780		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
781	<	}
782	<	aboutToWait.countDown();
781	>
782	>	Thread.currentThread().interrupt();
783		try {
784	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
784	>	q.poll(randomTimeout(), randomTimeUnit());
785	>	shouldThrow();
786	>	} catch (InterruptedException success) {}
787	>	assertFalse(Thread.interrupted());
788	>
789	>	pleaseInterrupt.countDown();
790	>	try {
791	>	q.poll(LONGER_DELAY_MS, MILLISECONDS);
792		shouldThrow();
793	<	} catch (InterruptedException success) {
794	<	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
764	<	}
793	>	} catch (InterruptedException success) {}
794	>	assertFalse(Thread.interrupted());
795		}});
796
797	<	aboutToWait.await();
798	<	waitForThreadToEnterWaitState(t, LONG_DELAY_MS);
797	>	await(pleaseInterrupt);
798	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
799		t.interrupt();
800		awaitTermination(t);
801		checkEmpty(q);
#	Line 824 | Line 854 | public class LinkedBlockingDequeTest ext
854		}});
855
856		await(pleaseInterrupt);
857	<	assertThreadStaysAlive(t);
857	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
858		t.interrupt();
859		awaitTermination(t);
860		assertEquals(SIZE, q.size());
#	Line 859 | Line 889 | public class LinkedBlockingDequeTest ext
889		assertEquals(capacity - 1, q.take());
890
891		await(pleaseInterrupt);
892	<	assertThreadStaysAlive(t);
892	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
893		t.interrupt();
894		awaitTermination(t);
895		assertEquals(0, q.remainingCapacity());
#	Line 868 | Line 898 | public class LinkedBlockingDequeTest ext
898		/**
899		* timed offerFirst times out if full and elements not taken
900		*/
901	<	public void testTimedOfferFirst() throws InterruptedException {
901	>	public void testTimedOfferFirst() {
902		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
903		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
904		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 876 | Line 906 | public class LinkedBlockingDequeTest ext
906		q.putFirst(new Object());
907		q.putFirst(new Object());
908		long startTime = System.nanoTime();
909	+
910		assertFalse(q.offerFirst(new Object(), timeoutMillis(), MILLISECONDS));
911		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
912	+
913	+	Thread.currentThread().interrupt();
914	+	try {
915	+	q.offerFirst(new Object(), randomTimeout(), randomTimeUnit());
916	+	shouldThrow();
917	+	} catch (InterruptedException success) {}
918	+	assertFalse(Thread.interrupted());
919	+
920		pleaseInterrupt.countDown();
921		try {
922	<	q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
922	>	q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
923		shouldThrow();
924		} catch (InterruptedException success) {}
925	+	assertFalse(Thread.interrupted());
926	+
927	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
928		}});
929
930		await(pleaseInterrupt);
931	<	assertThreadStaysAlive(t);
931	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
932		t.interrupt();
933		awaitTermination(t);
934		}
#	Line 918 | Line 960 | public class LinkedBlockingDequeTest ext
960		}});
961
962		await(threadStarted);
963	<	assertThreadStaysAlive(t);
963	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
964		t.interrupt();
965		awaitTermination(t);
966		}
#	Line 959 | Line 1001 | public class LinkedBlockingDequeTest ext
1001		}});
1002
1003		await(threadStarted);
1004	<	assertThreadStaysAlive(t);
1004	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1005		t.interrupt();
1006		awaitTermination(t);
1007		}
#	Line 991 | Line 1033 | public class LinkedBlockingDequeTest ext
1033		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1034		Thread t = newStartedThread(new CheckedRunnable() {
1035		public void realRun() throws InterruptedException {
1036	<	for (int i = 0; i < SIZE; ++i) {
995	<	assertEquals(i, q.takeFirst());
996	<	}
1036	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.takeFirst());
1037
1038		Thread.currentThread().interrupt();
1039		try {
#	Line 1011 | Line 1051 | public class LinkedBlockingDequeTest ext
1051		}});
1052
1053		await(pleaseInterrupt);
1054	<	assertThreadStaysAlive(t);
1054	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1055		t.interrupt();
1056		awaitTermination(t);
1057		}
#	Line 1052 | Line 1092 | public class LinkedBlockingDequeTest ext
1092		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1093		Thread t = newStartedThread(new CheckedRunnable() {
1094		public void realRun() throws InterruptedException {
1095	<	long startTime = System.nanoTime();
1056	<	for (int i = 0; i < SIZE; ++i) {
1095	>	for (int i = 0; i < SIZE; i++)
1096		assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1058	–	}
1097
1098		Thread.currentThread().interrupt();
1099		try {
1100	<	q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1100	>	q.pollFirst(randomTimeout(), randomTimeUnit());
1101		shouldThrow();
1102		} catch (InterruptedException success) {}
1103		assertFalse(Thread.interrupted());
1104
1105		pleaseInterrupt.countDown();
1106		try {
1107	<	q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1107	>	q.pollFirst(LONGER_DELAY_MS, MILLISECONDS);
1108		shouldThrow();
1109		} catch (InterruptedException success) {}
1110		assertFalse(Thread.interrupted());
1073	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1111		}});
1112
1113		await(pleaseInterrupt);
1114	<	assertThreadStaysAlive(t);
1114	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1115		t.interrupt();
1116		awaitTermination(t);
1117		}
#	Line 1098 | Line 1135 | public class LinkedBlockingDequeTest ext
1135
1136		Thread.currentThread().interrupt();
1137		try {
1138	<	q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1138	>	q.pollFirst(randomTimeout(), randomTimeUnit());
1139		shouldThrow();
1140		} catch (InterruptedException success) {}
1141
#	Line 1107 | Line 1144 | public class LinkedBlockingDequeTest ext
1144		q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1145		shouldThrow();
1146		} catch (InterruptedException success) {}
1147	+	assertFalse(Thread.interrupted());
1148	+
1149		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1150		}});
1151
#	Line 1115 | Line 1154 | public class LinkedBlockingDequeTest ext
1154		assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1155		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1156		barrier.await();
1157	<	assertThreadStaysAlive(t);
1157	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1158		t.interrupt();
1159		awaitTermination(t);
1160		}
#	Line 1173 | Line 1212 | public class LinkedBlockingDequeTest ext
1212		}});
1213
1214		await(pleaseInterrupt);
1215	<	assertThreadStaysAlive(t);
1215	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1216		t.interrupt();
1217		awaitTermination(t);
1218		assertEquals(SIZE, q.size());
#	Line 1195 | Line 1234 | public class LinkedBlockingDequeTest ext
1234		pleaseTake.countDown();
1235		q.putLast(86);
1236
1237	+	Thread.currentThread().interrupt();
1238	+	try {
1239	+	q.putLast(99);
1240	+	shouldThrow();
1241	+	} catch (InterruptedException success) {}
1242	+	assertFalse(Thread.interrupted());
1243	+
1244		pleaseInterrupt.countDown();
1245		try {
1246		q.putLast(99);
#	Line 1208 | Line 1254 | public class LinkedBlockingDequeTest ext
1254		assertEquals(0, q.take());
1255
1256		await(pleaseInterrupt);
1257	<	assertThreadStaysAlive(t);
1257	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1258		t.interrupt();
1259		awaitTermination(t);
1260		assertEquals(0, q.remainingCapacity());
#	Line 1217 | Line 1263 | public class LinkedBlockingDequeTest ext
1263		/**
1264		* timed offerLast times out if full and elements not taken
1265		*/
1266	<	public void testTimedOfferLast() throws InterruptedException {
1266	>	public void testTimedOfferLast() {
1267		final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1268		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1269		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 1225 | Line 1271 | public class LinkedBlockingDequeTest ext
1271		q.putLast(new Object());
1272		q.putLast(new Object());
1273		long startTime = System.nanoTime();
1274	+
1275		assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS));
1276		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1277	+
1278	+	Thread.currentThread().interrupt();
1279	+	try {
1280	+	q.offerLast(new Object(), randomTimeout(), randomTimeUnit());
1281	+	shouldThrow();
1282	+	} catch (InterruptedException success) {}
1283	+
1284		pleaseInterrupt.countDown();
1285		try {
1286	<	q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1286	>	q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1287		shouldThrow();
1288		} catch (InterruptedException success) {}
1289	+
1290	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1291		}});
1292
1293		await(pleaseInterrupt);
1294	<	assertThreadStaysAlive(t);
1294	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1295		t.interrupt();
1296		awaitTermination(t);
1297		}
#	Line 1258 | Line 1314 | public class LinkedBlockingDequeTest ext
1314		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1315		Thread t = newStartedThread(new CheckedRunnable() {
1316		public void realRun() throws InterruptedException {
1317	<	for (int i = 0; i < SIZE; ++i) {
1317	>	for (int i = 0; i < SIZE; i++)
1318		assertEquals(SIZE - i - 1, q.takeLast());
1263	–	}
1319
1320		Thread.currentThread().interrupt();
1321		try {
#	Line 1278 | Line 1333 | public class LinkedBlockingDequeTest ext
1333		}});
1334
1335		await(pleaseInterrupt);
1336	<	assertThreadStaysAlive(t);
1336	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1337		t.interrupt();
1338		awaitTermination(t);
1339		}
#	Line 1319 | Line 1374 | public class LinkedBlockingDequeTest ext
1374		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1375		Thread t = newStartedThread(new CheckedRunnable() {
1376		public void realRun() throws InterruptedException {
1377	<	long startTime = System.nanoTime();
1323	<	for (int i = 0; i < SIZE; ++i) {
1377	>	for (int i = 0; i < SIZE; i++)
1378		assertEquals(SIZE - i - 1,
1379		q.pollLast(LONG_DELAY_MS, MILLISECONDS));
1326	–	}
1380
1381		Thread.currentThread().interrupt();
1382		try {
1383	<	q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1383	>	q.pollLast(randomTimeout(), randomTimeUnit());
1384		shouldThrow();
1385		} catch (InterruptedException success) {}
1386		assertFalse(Thread.interrupted());
1387
1388		pleaseInterrupt.countDown();
1389		try {
1390	<	q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1390	>	q.pollLast(LONGER_DELAY_MS, MILLISECONDS);
1391		shouldThrow();
1392		} catch (InterruptedException success) {}
1393		assertFalse(Thread.interrupted());
1341	–
1342	–	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1394		}});
1395
1396		await(pleaseInterrupt);
1397	<	assertThreadStaysAlive(t);
1397	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1398		t.interrupt();
1399		awaitTermination(t);
1400		checkEmpty(q);
#	Line 1368 | Line 1419 | public class LinkedBlockingDequeTest ext
1419
1420		Thread.currentThread().interrupt();
1421		try {
1422	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
1422	>	q.poll(randomTimeout(), randomTimeUnit());
1423		shouldThrow();
1424		} catch (InterruptedException success) {}
1425		assertFalse(Thread.interrupted());
#	Line 1379 | Line 1430 | public class LinkedBlockingDequeTest ext
1430		shouldThrow();
1431		} catch (InterruptedException success) {}
1432		assertFalse(Thread.interrupted());
1433	+
1434	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1435		}});
1436
1437		barrier.await();
#	Line 1387 | Line 1440 | public class LinkedBlockingDequeTest ext
1440		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1441
1442		barrier.await();
1443	<	assertThreadStaysAlive(t);
1443	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1444		t.interrupt();
1445		awaitTermination(t);
1446		}
#	Line 1489 | Line 1542 | public class LinkedBlockingDequeTest ext
1542		*/
1543		public void testToArray() throws InterruptedException {
1544		LinkedBlockingDeque q = populatedDeque(SIZE);
1545	<	Object[] o = q.toArray();
1546	<	for (int i = 0; i < o.length; i++)
1547	<	assertSame(o[i], q.poll());
1545	>	Object[] a = q.toArray();
1546	>	assertSame(Object[].class, a.getClass());
1547	>	for (Object o : a)
1548	>	assertSame(o, q.poll());
1549	>	assertTrue(q.isEmpty());
1550		}
1551
1552		/**
#	Line 1502 | Line 1557 | public class LinkedBlockingDequeTest ext
1557		Integer[] ints = new Integer[SIZE];
1558		Integer[] array = q.toArray(ints);
1559		assertSame(ints, array);
1560	<	for (int i = 0; i < ints.length; i++)
1561	<	assertSame(ints[i], q.remove());
1560	>	for (Integer o : ints)
1561	>	assertSame(o, q.remove());
1562	>	assertTrue(q.isEmpty());
1563		}
1564
1565		/**
#	Line 1719 | Line 1775 | public class LinkedBlockingDequeTest ext
1775		}
1776
1777		/**
1778	<	* A deserialized serialized deque has same elements in same order
1778	>	* A deserialized/reserialized deque has same elements in same order
1779		*/
1780		public void testSerialization() throws Exception {
1781		Queue x = populatedDeque(SIZE);

Diff Legend

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