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.83 by jsr166, Mon May 28 21:19:50 2018 UTC vs.
Revision 1.84 by jsr166, Sun Aug 11 22:29:27 2019 UTC

#	Line 604 | Line 604 | public class LinkedBlockingDequeTest ext
604		}});
605
606		await(pleaseInterrupt);
607	<	assertThreadBlocks(t, Thread.State.WAITING);
607	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
608		t.interrupt();
609		awaitTermination(t);
610		assertEquals(SIZE, q.size());
#	Line 646 | Line 646 | public class LinkedBlockingDequeTest ext
646		assertEquals(0, q.take());
647
648		await(pleaseInterrupt);
649	<	assertThreadBlocks(t, Thread.State.WAITING);
649	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
650		t.interrupt();
651		awaitTermination(t);
652		assertEquals(0, q.remainingCapacity());
#	Line 663 | 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(), 2 * LONG_DELAY_MS, MILLISECONDS);
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(), LONG_DELAY_MS, MILLISECONDS);
680		shouldThrow();
681		} catch (InterruptedException success) {}
682		assertFalse(Thread.interrupted());
683	+
684	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
685		}});
686
687		await(pleaseInterrupt);
688	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
688	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
689		t.interrupt();
690		awaitTermination(t);
691		}
#	Line 723 | Line 726 | public class LinkedBlockingDequeTest ext
726		}});
727
728		await(pleaseInterrupt);
729	<	assertThreadBlocks(t, Thread.State.WAITING);
729	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
730		t.interrupt();
731		awaitTermination(t);
732		}
#	Line 781 | Line 784 | public class LinkedBlockingDequeTest ext
784
785		Thread.currentThread().interrupt();
786		try {
787	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
787	>	q.poll(randomTimeout(), randomTimeUnit());
788		shouldThrow();
789		} catch (InterruptedException success) {}
790		assertFalse(Thread.interrupted());
#	Line 797 | Line 800 | public class LinkedBlockingDequeTest ext
800		}});
801
802		await(pleaseInterrupt);
803	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
803	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
804		t.interrupt();
805		awaitTermination(t);
806		checkEmpty(q);
#	Line 856 | Line 859 | public class LinkedBlockingDequeTest ext
859		}});
860
861		await(pleaseInterrupt);
862	<	assertThreadBlocks(t, Thread.State.WAITING);
862	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
863		t.interrupt();
864		awaitTermination(t);
865		assertEquals(SIZE, q.size());
#	Line 891 | Line 894 | public class LinkedBlockingDequeTest ext
894		assertEquals(capacity - 1, q.take());
895
896		await(pleaseInterrupt);
897	<	assertThreadBlocks(t, Thread.State.WAITING);
897	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
898		t.interrupt();
899		awaitTermination(t);
900		assertEquals(0, q.remainingCapacity());
#	Line 908 | Line 911 | public class LinkedBlockingDequeTest ext
911		q.putFirst(new Object());
912		q.putFirst(new Object());
913		long startTime = System.nanoTime();
914	+
915		assertFalse(q.offerFirst(new Object(), timeoutMillis(), MILLISECONDS));
916		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
917
918		Thread.currentThread().interrupt();
919		try {
920	<	q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
920	>	q.offerFirst(new Object(), randomTimeout(), randomTimeUnit());
921		shouldThrow();
922		} catch (InterruptedException success) {}
923		assertFalse(Thread.interrupted());
924
925		pleaseInterrupt.countDown();
926		try {
927	<	q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
927	>	q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
928		shouldThrow();
929		} catch (InterruptedException success) {}
930		assertFalse(Thread.interrupted());
931	+
932	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
933		}});
934
935		await(pleaseInterrupt);
936	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
936	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
937		t.interrupt();
938		awaitTermination(t);
939		}
#	Line 959 | Line 965 | public class LinkedBlockingDequeTest ext
965		}});
966
967		await(threadStarted);
968	<	assertThreadBlocks(t, Thread.State.WAITING);
968	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
969		t.interrupt();
970		awaitTermination(t);
971		}
#	Line 1000 | Line 1006 | public class LinkedBlockingDequeTest ext
1006		}});
1007
1008		await(threadStarted);
1009	<	assertThreadBlocks(t, Thread.State.WAITING);
1009	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1010		t.interrupt();
1011		awaitTermination(t);
1012		}
#	Line 1050 | Line 1056 | public class LinkedBlockingDequeTest ext
1056		}});
1057
1058		await(pleaseInterrupt);
1059	<	assertThreadBlocks(t, Thread.State.WAITING);
1059	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1060		t.interrupt();
1061		awaitTermination(t);
1062		}
#	Line 1097 | Line 1103 | public class LinkedBlockingDequeTest ext
1103
1104		Thread.currentThread().interrupt();
1105		try {
1106	<	q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1106	>	q.pollFirst(randomTimeout(), randomTimeUnit());
1107		shouldThrow();
1108		} catch (InterruptedException success) {}
1109		assertFalse(Thread.interrupted());
#	Line 1113 | Line 1119 | public class LinkedBlockingDequeTest ext
1119		}});
1120
1121		await(pleaseInterrupt);
1122	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1122	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1123		t.interrupt();
1124		awaitTermination(t);
1125		}
#	Line 1137 | Line 1143 | public class LinkedBlockingDequeTest ext
1143
1144		Thread.currentThread().interrupt();
1145		try {
1146	<	q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1146	>	q.pollFirst(randomTimeout(), randomTimeUnit());
1147		shouldThrow();
1148		} catch (InterruptedException success) {}
1149
#	Line 1147 | Line 1153 | public class LinkedBlockingDequeTest ext
1153		shouldThrow();
1154		} catch (InterruptedException success) {}
1155		assertFalse(Thread.interrupted());
1156	+
1157		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1158		}});
1159
#	Line 1155 | Line 1162 | public class LinkedBlockingDequeTest ext
1162		assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1163		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1164		barrier.await();
1165	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1165	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1166		t.interrupt();
1167		awaitTermination(t);
1168		}
#	Line 1213 | Line 1220 | public class LinkedBlockingDequeTest ext
1220		}});
1221
1222		await(pleaseInterrupt);
1223	<	assertThreadBlocks(t, Thread.State.WAITING);
1223	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1224		t.interrupt();
1225		awaitTermination(t);
1226		assertEquals(SIZE, q.size());
#	Line 1255 | Line 1262 | public class LinkedBlockingDequeTest ext
1262		assertEquals(0, q.take());
1263
1264		await(pleaseInterrupt);
1265	<	assertThreadBlocks(t, Thread.State.WAITING);
1265	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1266		t.interrupt();
1267		awaitTermination(t);
1268		assertEquals(0, q.remainingCapacity());
#	Line 1272 | Line 1279 | public class LinkedBlockingDequeTest ext
1279		q.putLast(new Object());
1280		q.putLast(new Object());
1281		long startTime = System.nanoTime();
1282	+
1283		assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS));
1284		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1285
1286		Thread.currentThread().interrupt();
1287		try {
1288	<	q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1288	>	q.offerLast(new Object(), randomTimeout(), randomTimeUnit());
1289		shouldThrow();
1290		} catch (InterruptedException success) {}
1291
1292		pleaseInterrupt.countDown();
1293		try {
1294	<	q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1294	>	q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1295		shouldThrow();
1296		} catch (InterruptedException success) {}
1297	+
1298	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1299		}});
1300
1301		await(pleaseInterrupt);
1302	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1302	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1303		t.interrupt();
1304		awaitTermination(t);
1305		}
#	Line 1331 | Line 1341 | public class LinkedBlockingDequeTest ext
1341		}});
1342
1343		await(pleaseInterrupt);
1344	<	assertThreadBlocks(t, Thread.State.WAITING);
1344	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1345		t.interrupt();
1346		awaitTermination(t);
1347		}
#	Line 1379 | Line 1389 | public class LinkedBlockingDequeTest ext
1389
1390		Thread.currentThread().interrupt();
1391		try {
1392	<	q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1392	>	q.pollLast(randomTimeout(), randomTimeUnit());
1393		shouldThrow();
1394		} catch (InterruptedException success) {}
1395		assertFalse(Thread.interrupted());
#	Line 1395 | Line 1405 | public class LinkedBlockingDequeTest ext
1405		}});
1406
1407		await(pleaseInterrupt);
1408	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1408	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1409		t.interrupt();
1410		awaitTermination(t);
1411		checkEmpty(q);
#	Line 1420 | Line 1430 | public class LinkedBlockingDequeTest ext
1430
1431		Thread.currentThread().interrupt();
1432		try {
1433	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
1433	>	q.poll(randomTimeout(), randomTimeUnit());
1434		shouldThrow();
1435		} catch (InterruptedException success) {}
1436		assertFalse(Thread.interrupted());
#	Line 1441 | Line 1451 | public class LinkedBlockingDequeTest ext
1451		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1452
1453		barrier.await();
1454	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1454	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1455		t.interrupt();
1456		awaitTermination(t);
1457		}

Diff Legend

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