ViewVC Help

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

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

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.93 by jsr166, Mon May 29 19:15:03 2017 UTC vs.
Revision 1.99 by dl, Tue Jan 26 13:33:06 2021 UTC

#	Line 11 | Line 11 | import static java.util.concurrent.TimeU
11		import static java.util.concurrent.TimeUnit.SECONDS;
12
13		import java.util.ArrayList;
14	+	import java.util.Collection;
15	+	import java.util.Collections;
16		import java.util.HashSet;
17		import java.util.List;
18		import java.util.concurrent.BlockingQueue;
#	Line 64 | Line 66 | public class ScheduledExecutorTest exten
66		try (PoolCleaner cleaner = cleaner(p)) {
67		final long startTime = System.nanoTime();
68		final CountDownLatch done = new CountDownLatch(1);
69	<	Callable task = new CheckedCallable<Boolean>() {
69	>	Callable<Boolean> task = new CheckedCallable<Boolean>() {
70		public Boolean realCall() {
71		done.countDown();
72		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
73		return Boolean.TRUE;
74		}};
75	<	Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
75	>	Future<Boolean> f = p.schedule(task, timeoutMillis(), MILLISECONDS);
76		assertSame(Boolean.TRUE, f.get());
77		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
78		assertEquals(0L, done.getCount());
#	Line 90 | Line 92 | public class ScheduledExecutorTest exten
92		done.countDown();
93		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
94		}};
95	<	Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
95	>	Future<?> f = p.schedule(task, timeoutMillis(), MILLISECONDS);
96		await(done);
97		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
98		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
#	Line 110 | Line 112 | public class ScheduledExecutorTest exten
112		done.countDown();
113		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
114		}};
115	<	ScheduledFuture f =
115	>	ScheduledFuture<?> f =
116		p.scheduleAtFixedRate(task, timeoutMillis(),
117		LONG_DELAY_MS, MILLISECONDS);
118		await(done);
#	Line 132 | Line 134 | public class ScheduledExecutorTest exten
134		done.countDown();
135		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
136		}};
137	<	ScheduledFuture f =
137	>	ScheduledFuture<?> f =
138		p.scheduleWithFixedDelay(task, timeoutMillis(),
139		LONG_DELAY_MS, MILLISECONDS);
140		await(done);
#	Line 160 | Line 162 | public class ScheduledExecutorTest exten
162		final CountDownLatch done = new CountDownLatch(cycles);
163		final Runnable task = new CheckedRunnable() {
164		public void realRun() { done.countDown(); }};
165	<	final ScheduledFuture periodicTask =
165	>	final ScheduledFuture<?> periodicTask =
166		p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
167		final int totalDelayMillis = (cycles - 1) * delay;
168		await(done, totalDelayMillis + LONG_DELAY_MS);
#	Line 206 | Line 208 | public class ScheduledExecutorTest exten
208		previous.set(now);
209		done.countDown();
210		}};
211	<	final ScheduledFuture periodicTask =
211	>	final ScheduledFuture<?> periodicTask =
212		p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
213		final int totalDelayMillis = (cycles - 1) * delay;
214		await(done, totalDelayMillis + cycles * LONG_DELAY_MS);
#	Line 222 | Line 224 | public class ScheduledExecutorTest exten
224		}
225
226		/**
227	<	* execute(null) throws NPE
227	>	* Submitting null tasks throws NullPointerException
228		*/
229	<	public void testExecuteNull() throws InterruptedException {
229	>	public void testNullTaskSubmission() {
230		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
231		try (PoolCleaner cleaner = cleaner(p)) {
232	<	try {
231	<	p.execute(null);
232	<	shouldThrow();
233	<	} catch (NullPointerException success) {}
232	>	assertNullTaskSubmissionThrowsNullPointerException(p);
233		}
234		}
235
236		/**
237	<	* schedule(null) throws NPE
237	>	* Submitted tasks are rejected when shutdown
238		*/
239	<	public void testScheduleNull() throws InterruptedException {
239	>	public void testSubmittedTasksRejectedWhenShutdown() throws InterruptedException {
240		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
241	<	try (PoolCleaner cleaner = cleaner(p)) {
242	<	try {
243	<	Future f = p.schedule((Callable)null,
244	<	randomTimeout(), randomTimeUnit());
245	<	shouldThrow();
246	<	} catch (NullPointerException success) {}
247	<	}
248	<	}
241	>	final ThreadLocalRandom rnd = ThreadLocalRandom.current();
242	>	final CountDownLatch threadsStarted = new CountDownLatch(p.getCorePoolSize());
243	>	final CountDownLatch done = new CountDownLatch(1);
244	>	final Runnable r = () -> {
245	>	threadsStarted.countDown();
246	>	for (;;) {
247	>	try {
248	>	done.await();
249	>	return;
250	>	} catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
251	>	}};
252	>	final Callable<Boolean> c = () -> {
253	>	threadsStarted.countDown();
254	>	for (;;) {
255	>	try {
256	>	done.await();
257	>	return Boolean.TRUE;
258	>	} catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
259	>	}};
260
261	<	/**
262	<	* execute throws RejectedExecutionException if shutdown
263	<	*/
264	<	public void testSchedule1_RejectedExecutionException() throws InterruptedException {
265	<	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
266	<	try (PoolCleaner cleaner = cleaner(p)) {
267	<	try {
268	<	p.shutdown();
269	<	p.schedule(new NoOpRunnable(),
260	<	MEDIUM_DELAY_MS, MILLISECONDS);
261	<	shouldThrow();
262	<	} catch (RejectedExecutionException success) {
263	<	} catch (SecurityException ok) {}
264	<	}
265	<	}
261	>	try (PoolCleaner cleaner = cleaner(p, done)) {
262	>	for (int i = p.getCorePoolSize(); i--> 0; ) {
263	>	switch (rnd.nextInt(4)) {
264	>	case 0: p.execute(r); break;
265	>	case 1: assertFalse(p.submit(r).isDone()); break;
266	>	case 2: assertFalse(p.submit(r, Boolean.TRUE).isDone()); break;
267	>	case 3: assertFalse(p.submit(c).isDone()); break;
268	>	}
269	>	}
270
271	<	/**
272	<	* schedule throws RejectedExecutionException if shutdown
269	<	*/
270	<	public void testSchedule2_RejectedExecutionException() throws InterruptedException {
271	<	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
272	<	try (PoolCleaner cleaner = cleaner(p)) {
273	<	try {
274	<	p.shutdown();
275	<	p.schedule(new NoOpCallable(),
276	<	MEDIUM_DELAY_MS, MILLISECONDS);
277	<	shouldThrow();
278	<	} catch (RejectedExecutionException success) {
279	<	} catch (SecurityException ok) {}
280	<	}
281	<	}
271	>	// ScheduledThreadPoolExecutor has an unbounded queue, so never saturated.
272	>	await(threadsStarted);
273
274	<	/**
275	<	* schedule callable throws RejectedExecutionException if shutdown
276	<	*/
286	<	public void testSchedule3_RejectedExecutionException() throws InterruptedException {
287	<	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
288	<	try (PoolCleaner cleaner = cleaner(p)) {
289	<	try {
274	>	if (rnd.nextBoolean())
275	>	p.shutdownNow();
276	>	else
277		p.shutdown();
278	<	p.schedule(new NoOpCallable(),
279	<	MEDIUM_DELAY_MS, MILLISECONDS);
280	<	shouldThrow();
294	<	} catch (RejectedExecutionException success) {
295	<	} catch (SecurityException ok) {}
296	<	}
297	<	}
278	>	// Pool is shutdown, but not yet terminated
279	>	assertTaskSubmissionsAreRejected(p);
280	>	assertFalse(p.isTerminated());
281
282	<	/**
283	<	* scheduleAtFixedRate throws RejectedExecutionException if shutdown
301	<	*/
302	<	public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
303	<	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
304	<	try (PoolCleaner cleaner = cleaner(p)) {
305	<	try {
306	<	p.shutdown();
307	<	p.scheduleAtFixedRate(new NoOpRunnable(),
308	<	MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
309	<	shouldThrow();
310	<	} catch (RejectedExecutionException success) {
311	<	} catch (SecurityException ok) {}
312	<	}
313	<	}
282	>	done.countDown();   // release blocking tasks
283	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
284
285	<	/**
316	<	* scheduleWithFixedDelay throws RejectedExecutionException if shutdown
317	<	*/
318	<	public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException {
319	<	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
320	<	try (PoolCleaner cleaner = cleaner(p)) {
321	<	try {
322	<	p.shutdown();
323	<	p.scheduleWithFixedDelay(new NoOpRunnable(),
324	<	MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
325	<	shouldThrow();
326	<	} catch (RejectedExecutionException success) {
327	<	} catch (SecurityException ok) {}
285	>	assertTaskSubmissionsAreRejected(p);
286		}
287	+	assertEquals(p.getCorePoolSize(), p.getCompletedTaskCount());
288		}
289
290		/**
#	Line 590 | Line 549 | public class ScheduledExecutorTest exten
549		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
550		try (PoolCleaner cleaner = cleaner(p, done)) {
551		final CountDownLatch threadStarted = new CountDownLatch(1);
552	<	ScheduledFuture[] tasks = new ScheduledFuture[5];
552	>	@SuppressWarnings("unchecked")
553	>	ScheduledFuture<?>[] tasks = (ScheduledFuture<?>[])new ScheduledFuture[5];
554		for (int i = 0; i < tasks.length; i++) {
555		Runnable r = new CheckedRunnable() {
556		public void realRun() throws InterruptedException {
#	Line 613 | Line 573 | public class ScheduledExecutorTest exten
573		final CountDownLatch done = new CountDownLatch(1);
574		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
575		try (PoolCleaner cleaner = cleaner(p, done)) {
576	<	ScheduledFuture[] tasks = new ScheduledFuture[5];
576	>	@SuppressWarnings("unchecked")
577	>	ScheduledFuture<?>[] tasks = (ScheduledFuture<?>[])new ScheduledFuture[5];
578		final CountDownLatch threadStarted = new CountDownLatch(1);
579		for (int i = 0; i < tasks.length; i++) {
580		Runnable r = new CheckedRunnable() {
#	Line 641 | Line 602 | public class ScheduledExecutorTest exten
602		* purge eventually removes cancelled tasks from the queue
603		*/
604		public void testPurge() throws InterruptedException {
605	<	final ScheduledFuture[] tasks = new ScheduledFuture[5];
605	>	@SuppressWarnings("unchecked")
606	>	ScheduledFuture<?>[] tasks = (ScheduledFuture<?>[])new ScheduledFuture[5];
607		final Runnable releaser = new Runnable() { public void run() {
608	<	for (ScheduledFuture task : tasks)
608	>	for (ScheduledFuture<?> task : tasks)
609		if (task != null) task.cancel(true); }};
610		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
611		try (PoolCleaner cleaner = cleaner(p, releaser)) {
612		for (int i = 0; i < tasks.length; i++)
613	<	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
613	>	tasks[i] = p.schedule(possiblyInterruptedRunnable(SMALL_DELAY_MS),
614		LONG_DELAY_MS, MILLISECONDS);
615		int max = tasks.length;
616		if (tasks[4].cancel(true)) --max;
#	Line 680 | Line 642 | public class ScheduledExecutorTest exten
642		Runnable waiter = new CheckedRunnable() { public void realRun() {
643		threadsStarted.countDown();
644		try {
645	<	MILLISECONDS.sleep(2 * LONG_DELAY_MS);
645	>	MILLISECONDS.sleep(LONGER_DELAY_MS);
646		} catch (InterruptedException success) {}
647		ran.getAndIncrement();
648		}};
#	Line 710 | Line 672 | public class ScheduledExecutorTest exten
672		*/
673		public void testShutdownNow_delayedTasks() throws InterruptedException {
674		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
675	<	List<ScheduledFuture> tasks = new ArrayList<>();
675	>	List<ScheduledFuture<?>> tasks = new ArrayList<>();
676		for (int i = 0; i < 3; i++) {
677		Runnable r = new NoOpRunnable();
678		tasks.add(p.schedule(r, 9, SECONDS));
#	Line 718 | Line 680 | public class ScheduledExecutorTest exten
680		tasks.add(p.scheduleWithFixedDelay(r, 9, 9, SECONDS));
681		}
682		if (testImplementationDetails)
683	<	assertEquals(new HashSet(tasks), new HashSet(p.getQueue()));
683	>	assertEquals(new HashSet<Object>(tasks), new HashSet<Object>(p.getQueue()));
684		final List<Runnable> queuedTasks;
685		try {
686		queuedTasks = p.shutdownNow();
#	Line 728 | Line 690 | public class ScheduledExecutorTest exten
690		assertTrue(p.isShutdown());
691		assertTrue(p.getQueue().isEmpty());
692		if (testImplementationDetails)
693	<	assertEquals(new HashSet(tasks), new HashSet(queuedTasks));
693	>	assertEquals(new HashSet<Object>(tasks), new HashSet<Object>(queuedTasks));
694		assertEquals(tasks.size(), queuedTasks.size());
695	<	for (ScheduledFuture task : tasks) {
695	>	for (ScheduledFuture<?> task : tasks) {
696		assertFalse(task.isDone());
697		assertFalse(task.isCancelled());
698		}
#	Line 745 | Line 707 | public class ScheduledExecutorTest exten
707		* - setExecuteExistingDelayedTasksAfterShutdownPolicy
708		* - setContinueExistingPeriodicTasksAfterShutdownPolicy
709		*/
710	+	@SuppressWarnings("FutureReturnValueIgnored")
711		public void testShutdown_cancellation() throws Exception {
712		final int poolSize = 4;
713		final ScheduledThreadPoolExecutor p
#	Line 844 | Line 807 | public class ScheduledExecutorTest exten
807		immediates.forEach(
808		f -> assertTrue(((ScheduledFuture)f).getDelay(NANOSECONDS) <= 0L));
809
810	<	Stream.of(immediates, delayeds, periodics).flatMap(c -> c.stream())
810	>	Stream.of(immediates, delayeds, periodics).flatMap(Collection::stream)
811		.forEach(f -> assertFalse(f.isDone()));
812
813		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 898 | Line 861 | public class ScheduledExecutorTest exten
861
862		assertTrue(q.isEmpty());
863
864	<	Stream.of(immediates, delayeds, periodics).flatMap(c -> c.stream())
864	>	Stream.of(immediates, delayeds, periodics).flatMap(Collection::stream)
865		.forEach(f -> assertTrue(f.isDone()));
866
867		for (Future<?> f : immediates) assertNull(f.get());
#	Line 964 | Line 927 | public class ScheduledExecutorTest exten
927		}
928
929		/**
930	<	* invokeAny(null) throws NPE
930	>	* invokeAny(null) throws NullPointerException
931		*/
932		public void testInvokeAny1() throws Exception {
933		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
#	Line 977 | Line 940 | public class ScheduledExecutorTest exten
940		}
941
942		/**
943	<	* invokeAny(empty collection) throws IAE
943	>	* invokeAny(empty collection) throws IllegalArgumentException
944		*/
945		public void testInvokeAny2() throws Exception {
946		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
#	Line 990 | Line 953 | public class ScheduledExecutorTest exten
953		}
954
955		/**
956	<	* invokeAny(c) throws NPE if c has null elements
956	>	* invokeAny(c) throws NullPointerException if c has null elements
957		*/
958		public void testInvokeAny3() throws Exception {
959		CountDownLatch latch = new CountDownLatch(1);
#	Line 1052 | Line 1015 | public class ScheduledExecutorTest exten
1015		}
1016
1017		/**
1018	<	* invokeAll(empty collection) returns empty collection
1018	>	* invokeAll(empty collection) returns empty list
1019		*/
1020		public void testInvokeAll2() throws Exception {
1021		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1022	+	final Collection<Callable<String>> emptyCollection
1023	+	= Collections.emptyList();
1024		try (PoolCleaner cleaner = cleaner(e)) {
1025	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1025	>	List<Future<String>> r = e.invokeAll(emptyCollection);
1026		assertTrue(r.isEmpty());
1027		}
1028		}
#	Line 1120 | Line 1085 | public class ScheduledExecutorTest exten
1085		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1086		try (PoolCleaner cleaner = cleaner(e)) {
1087		try {
1088	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1088	>	e.invokeAny(null, randomTimeout(), randomTimeUnit());
1089		shouldThrow();
1090		} catch (NullPointerException success) {}
1091		}
1092		}
1093
1094		/**
1095	<	* timed invokeAny(,,null) throws NPE
1095	>	* timed invokeAny(,,null) throws NullPointerException
1096		*/
1097		public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1098		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
#	Line 1135 | Line 1100 | public class ScheduledExecutorTest exten
1100		List<Callable<String>> l = new ArrayList<>();
1101		l.add(new StringTask());
1102		try {
1103	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1103	>	e.invokeAny(l, randomTimeout(), null);
1104		shouldThrow();
1105		} catch (NullPointerException success) {}
1106		}
1107		}
1108
1109		/**
1110	<	* timed invokeAny(empty collection) throws IAE
1110	>	* timed invokeAny(empty collection) throws IllegalArgumentException
1111		*/
1112		public void testTimedInvokeAny2() throws Exception {
1113		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1114	+	final Collection<Callable<String>> emptyCollection
1115	+	= Collections.emptyList();
1116		try (PoolCleaner cleaner = cleaner(e)) {
1117		try {
1118	<	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1118	>	e.invokeAny(emptyCollection, randomTimeout(), randomTimeUnit());
1119		shouldThrow();
1120		} catch (IllegalArgumentException success) {}
1121		}
#	Line 1165 | Line 1132 | public class ScheduledExecutorTest exten
1132		l.add(latchAwaitingStringTask(latch));
1133		l.add(null);
1134		try {
1135	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1135	>	e.invokeAny(l, randomTimeout(), randomTimeUnit());
1136		shouldThrow();
1137		} catch (NullPointerException success) {}
1138		latch.countDown();
#	Line 1214 | Line 1181 | public class ScheduledExecutorTest exten
1181		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1182		try (PoolCleaner cleaner = cleaner(e)) {
1183		try {
1184	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1184	>	e.invokeAll(null, randomTimeout(), randomTimeUnit());
1185		shouldThrow();
1186		} catch (NullPointerException success) {}
1187		}
#	Line 1229 | Line 1196 | public class ScheduledExecutorTest exten
1196		List<Callable<String>> l = new ArrayList<>();
1197		l.add(new StringTask());
1198		try {
1199	<	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1199	>	e.invokeAll(l, randomTimeout(), null);
1200		shouldThrow();
1201		} catch (NullPointerException success) {}
1202		}
1203		}
1204
1205		/**
1206	<	* timed invokeAll(empty collection) returns empty collection
1206	>	* timed invokeAll(empty collection) returns empty list
1207		*/
1208		public void testTimedInvokeAll2() throws Exception {
1209		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1210	+	final Collection<Callable<String>> emptyCollection
1211	+	= Collections.emptyList();
1212		try (PoolCleaner cleaner = cleaner(e)) {
1213	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1214	<	MEDIUM_DELAY_MS, MILLISECONDS);
1213	>	List<Future<String>> r =
1214	>	e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1215		assertTrue(r.isEmpty());
1216		}
1217		}
#	Line 1257 | Line 1226 | public class ScheduledExecutorTest exten
1226		l.add(new StringTask());
1227		l.add(null);
1228		try {
1229	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1229	>	e.invokeAll(l, randomTimeout(), randomTimeUnit());
1230		shouldThrow();
1231		} catch (NullPointerException success) {}
1232		}
#	Line 1322 | Line 1291 | public class ScheduledExecutorTest exten
1291		p.invokeAll(tasks, timeout, MILLISECONDS);
1292		assertEquals(tasks.size(), futures.size());
1293		assertTrue(millisElapsedSince(startTime) >= timeout);
1294	<	for (Future future : futures)
1294	>	for (Future<?> future : futures)
1295		assertTrue(future.isDone());
1296		assertTrue(futures.get(1).isCancelled());
1297		try {
#	Line 1343 | Line 1312 | public class ScheduledExecutorTest exten
1312		* one-shot task from executing.
1313		* https://bugs.openjdk.java.net/browse/JDK-8051859
1314		*/
1315	+	@SuppressWarnings("FutureReturnValueIgnored")
1316		public void testScheduleWithFixedDelay_overflow() throws Exception {
1317		final CountDownLatch delayedDone = new CountDownLatch(1);
1318		final CountDownLatch immediateDone = new CountDownLatch(1);
1319		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
1320		try (PoolCleaner cleaner = cleaner(p)) {
1321	<	final Runnable immediate = new Runnable() { public void run() {
1352	<	immediateDone.countDown();
1353	<	}};
1354	<	final Runnable delayed = new Runnable() { public void run() {
1321	>	final Runnable delayed = () -> {
1322		delayedDone.countDown();
1323	<	p.submit(immediate);
1324	<	}};
1323	>	p.submit(() -> immediateDone.countDown());
1324	>	};
1325		p.scheduleWithFixedDelay(delayed, 0L, Long.MAX_VALUE, SECONDS);
1326		await(delayedDone);
1327		await(immediateDone);

Diff Legend

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