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.76 by jsr166, Thu Oct 8 03:08:37 2015 UTC vs.
Revision 1.94 by jsr166, Mon May 29 22:44:27 2017 UTC

#	Line 7 | Line 7
7		*/
8
9		import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	+	import static java.util.concurrent.TimeUnit.NANOSECONDS;
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 17 | Line 20 | import java.util.concurrent.Callable;
20		import java.util.concurrent.CancellationException;
21		import java.util.concurrent.CountDownLatch;
22		import java.util.concurrent.ExecutionException;
20	–	import java.util.concurrent.Executors;
23		import java.util.concurrent.ExecutorService;
24		import java.util.concurrent.Future;
25		import java.util.concurrent.RejectedExecutionException;
26		import java.util.concurrent.ScheduledFuture;
27		import java.util.concurrent.ScheduledThreadPoolExecutor;
28		import java.util.concurrent.ThreadFactory;
29	+	import java.util.concurrent.ThreadLocalRandom;
30		import java.util.concurrent.ThreadPoolExecutor;
31	+	import java.util.concurrent.atomic.AtomicBoolean;
32		import java.util.concurrent.atomic.AtomicInteger;
33	+	import java.util.concurrent.atomic.AtomicLong;
34	+	import java.util.stream.Stream;
35
36		import junit.framework.Test;
37		import junit.framework.TestSuite;
#	Line 48 | Line 54 | public class ScheduledExecutorTest exten
54		final Runnable task = new CheckedRunnable() {
55		public void realRun() { done.countDown(); }};
56		p.execute(task);
57	<	assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
57	>	await(done);
58		}
59		}
60
#	Line 69 | Line 75 | public class ScheduledExecutorTest exten
75		Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
76		assertSame(Boolean.TRUE, f.get());
77		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
78	<	assertTrue(done.await(0L, MILLISECONDS));
78	>	assertEquals(0L, done.getCount());
79		}
80		}
81
#	Line 143 | Line 149 | public class ScheduledExecutorTest exten
149		}
150
151		/**
152	<	* scheduleAtFixedRate executes series of tasks at given rate
152	>	* scheduleAtFixedRate executes series of tasks at given rate.
153	>	* Eventually, it must hold that:
154	>	*   cycles - 1 <= elapsedMillis/delay < cycles
155		*/
156		public void testFixedRateSequence() throws InterruptedException {
157		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
158		try (PoolCleaner cleaner = cleaner(p)) {
159		for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
160	<	long startTime = System.nanoTime();
161	<	int cycles = 10;
160	>	final long startTime = System.nanoTime();
161	>	final int cycles = 8;
162		final CountDownLatch done = new CountDownLatch(cycles);
163	<	Runnable task = new CheckedRunnable() {
163	>	final Runnable task = new CheckedRunnable() {
164		public void realRun() { done.countDown(); }};
165	<	ScheduledFuture h =
165	>	final ScheduledFuture periodicTask =
166		p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
167	<	await(done);
168	<	h.cancel(true);
169	<	double normalizedTime =
170	<	(double) millisElapsedSince(startTime) / delay;
171	<	if (normalizedTime >= cycles - 1 &&
172	<	normalizedTime <= cycles)
167	>	final int totalDelayMillis = (cycles - 1) * delay;
168	>	await(done, totalDelayMillis + LONG_DELAY_MS);
169	>	periodicTask.cancel(true);
170	>	final long elapsedMillis = millisElapsedSince(startTime);
171	>	assertTrue(elapsedMillis >= totalDelayMillis);
172	>	if (elapsedMillis <= cycles * delay)
173		return;
174	+	// else retry with longer delay
175		}
176	<	throw new AssertionError("unexpected execution rate");
176	>	fail("unexpected execution rate");
177		}
178		}
179
180		/**
181	<	* scheduleWithFixedDelay executes series of tasks with given period
181	>	* scheduleWithFixedDelay executes series of tasks with given period.
182	>	* Eventually, it must hold that each task starts at least delay and at
183	>	* most 2 * delay after the termination of the previous task.
184		*/
185		public void testFixedDelaySequence() throws InterruptedException {
186		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
187		try (PoolCleaner cleaner = cleaner(p)) {
188		for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
189	<	long startTime = System.nanoTime();
190	<	int cycles = 10;
189	>	final long startTime = System.nanoTime();
190	>	final AtomicLong previous = new AtomicLong(startTime);
191	>	final AtomicBoolean tryLongerDelay = new AtomicBoolean(false);
192	>	final int cycles = 8;
193		final CountDownLatch done = new CountDownLatch(cycles);
194	<	Runnable task = new CheckedRunnable() {
195	<	public void realRun() { done.countDown(); }};
196	<	ScheduledFuture h =
194	>	final int d = delay;
195	>	final Runnable task = new CheckedRunnable() {
196	>	public void realRun() {
197	>	long now = System.nanoTime();
198	>	long elapsedMillis
199	>	= NANOSECONDS.toMillis(now - previous.get());
200	>	if (done.getCount() == cycles) { // first execution
201	>	if (elapsedMillis >= d)
202	>	tryLongerDelay.set(true);
203	>	} else {
204	>	assertTrue(elapsedMillis >= d);
205	>	if (elapsedMillis >= 2 * d)
206	>	tryLongerDelay.set(true);
207	>	}
208	>	previous.set(now);
209	>	done.countDown();
210	>	}};
211	>	final ScheduledFuture periodicTask =
212		p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
213	<	await(done);
214	<	h.cancel(true);
215	<	double normalizedTime =
216	<	(double) millisElapsedSince(startTime) / delay;
217	<	if (normalizedTime >= cycles - 1 &&
218	<	normalizedTime <= cycles)
213	>	final int totalDelayMillis = (cycles - 1) * delay;
214	>	await(done, totalDelayMillis + cycles * LONG_DELAY_MS);
215	>	periodicTask.cancel(true);
216	>	final long elapsedMillis = millisElapsedSince(startTime);
217	>	assertTrue(elapsedMillis >= totalDelayMillis);
218	>	if (!tryLongerDelay.get())
219		return;
220	+	// else retry with longer delay
221		}
222	<	throw new AssertionError("unexpected execution rate");
222	>	fail("unexpected execution rate");
223		}
224		}
225
#	Line 214 | Line 243 | public class ScheduledExecutorTest exten
243		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
244		try (PoolCleaner cleaner = cleaner(p)) {
245		try {
246	<	TrackedCallable callable = null;
247	<	Future f = p.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
246	>	Future f = p.schedule((Callable)null,
247	>	randomTimeout(), randomTimeUnit());
248		shouldThrow();
249		} catch (NullPointerException success) {}
250		}
#	Line 230 | Line 259 | public class ScheduledExecutorTest exten
259		try {
260		p.shutdown();
261		p.schedule(new NoOpRunnable(),
262	<	MEDIUM_DELAY_MS, MILLISECONDS);
262	>	randomTimeout(), randomTimeUnit());
263		shouldThrow();
264		} catch (RejectedExecutionException success) {
265		} catch (SecurityException ok) {}
#	Line 246 | Line 275 | public class ScheduledExecutorTest exten
275		try {
276		p.shutdown();
277		p.schedule(new NoOpCallable(),
278	<	MEDIUM_DELAY_MS, MILLISECONDS);
278	>	randomTimeout(), randomTimeUnit());
279		shouldThrow();
280		} catch (RejectedExecutionException success) {
281		} catch (SecurityException ok) {}
#	Line 262 | Line 291 | public class ScheduledExecutorTest exten
291		try {
292		p.shutdown();
293		p.schedule(new NoOpCallable(),
294	<	MEDIUM_DELAY_MS, MILLISECONDS);
294	>	randomTimeout(), randomTimeUnit());
295		shouldThrow();
296		} catch (RejectedExecutionException success) {
297		} catch (SecurityException ok) {}
#	Line 337 | Line 366 | public class ScheduledExecutorTest exten
366		public void realRun() throws InterruptedException {
367		threadStarted.countDown();
368		assertEquals(0, p.getCompletedTaskCount());
369	<	threadProceed.await();
369	>	await(threadProceed);
370		threadDone.countDown();
371		}});
372		await(threadStarted);
373		assertEquals(0, p.getCompletedTaskCount());
374		threadProceed.countDown();
375	<	threadDone.await();
375	>	await(threadDone);
376		long startTime = System.nanoTime();
377		while (p.getCompletedTaskCount() != 1) {
378		if (millisElapsedSince(startTime) > LONG_DELAY_MS)
#	Line 482 | Line 511 | public class ScheduledExecutorTest exten
511		}
512
513		/**
514	+	* The default rejected execution handler is AbortPolicy.
515	+	*/
516	+	public void testDefaultRejectedExecutionHandler() {
517	+	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
518	+	try (PoolCleaner cleaner = cleaner(p)) {
519	+	assertTrue(p.getRejectedExecutionHandler()
520	+	instanceof ThreadPoolExecutor.AbortPolicy);
521	+	}
522	+	}
523	+
524	+	/**
525		* isShutdown is false before shutdown, true after
526		*/
527		public void testIsShutdown() {
488	–
528		final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
529	<	try {
530	<	assertFalse(p.isShutdown());
531	<	}
532	<	finally {
533	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
529	>	assertFalse(p.isShutdown());
530	>	try (PoolCleaner cleaner = cleaner(p)) {
531	>	try {
532	>	p.shutdown();
533	>	assertTrue(p.isShutdown());
534	>	} catch (SecurityException ok) {}
535		}
496	–	assertTrue(p.isShutdown());
536		}
537
538		/**
#	Line 709 | Line 748 | public class ScheduledExecutorTest exten
748		* - setContinueExistingPeriodicTasksAfterShutdownPolicy
749		*/
750		public void testShutdown_cancellation() throws Exception {
751	<	Boolean[] allBooleans = { null, Boolean.FALSE, Boolean.TRUE };
713	<	for (Boolean policy : allBooleans)
714	<	{
715	<	final int poolSize = 2;
751	>	final int poolSize = 4;
752		final ScheduledThreadPoolExecutor p
753		= new ScheduledThreadPoolExecutor(poolSize);
754	<	final boolean effectiveDelayedPolicy = (policy != Boolean.FALSE);
755	<	final boolean effectivePeriodicPolicy = (policy == Boolean.TRUE);
756	<	final boolean effectiveRemovePolicy = (policy == Boolean.TRUE);
757	<	if (policy != null) {
758	<	p.setExecuteExistingDelayedTasksAfterShutdownPolicy(policy);
759	<	p.setContinueExistingPeriodicTasksAfterShutdownPolicy(policy);
760	<	p.setRemoveOnCancelPolicy(policy);
761	<	}
754	>	final BlockingQueue<Runnable> q = p.getQueue();
755	>	final ThreadLocalRandom rnd = ThreadLocalRandom.current();
756	>	final long delay = rnd.nextInt(2);
757	>	final int rounds = rnd.nextInt(1, 3);
758	>	final boolean effectiveDelayedPolicy;
759	>	final boolean effectivePeriodicPolicy;
760	>	final boolean effectiveRemovePolicy;
761	>
762	>	if (rnd.nextBoolean())
763	>	p.setExecuteExistingDelayedTasksAfterShutdownPolicy(
764	>	effectiveDelayedPolicy = rnd.nextBoolean());
765	>	else
766	>	effectiveDelayedPolicy = true;
767		assertEquals(effectiveDelayedPolicy,
768		p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
769	+
770	+	if (rnd.nextBoolean())
771	+	p.setContinueExistingPeriodicTasksAfterShutdownPolicy(
772	+	effectivePeriodicPolicy = rnd.nextBoolean());
773	+	else
774	+	effectivePeriodicPolicy = false;
775		assertEquals(effectivePeriodicPolicy,
776		p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
777	+
778	+	if (rnd.nextBoolean())
779	+	p.setRemoveOnCancelPolicy(
780	+	effectiveRemovePolicy = rnd.nextBoolean());
781	+	else
782	+	effectiveRemovePolicy = false;
783		assertEquals(effectiveRemovePolicy,
784		p.getRemoveOnCancelPolicy());
785	<	// Strategy: Wedge the pool with poolSize "blocker" threads
785	>
786	>	final boolean periodicTasksContinue = effectivePeriodicPolicy && rnd.nextBoolean();
787	>
788	>	// Strategy: Wedge the pool with one wave of "blocker" tasks,
789	>	// then add a second wave that waits in the queue until unblocked.
790		final AtomicInteger ran = new AtomicInteger(0);
791		final CountDownLatch poolBlocked = new CountDownLatch(poolSize);
792		final CountDownLatch unblock = new CountDownLatch(1);
793	<	final CountDownLatch periodicLatch1 = new CountDownLatch(2);
737	<	final CountDownLatch periodicLatch2 = new CountDownLatch(2);
738	<	Runnable task = new CheckedRunnable() { public void realRun()
739	<	throws InterruptedException {
740	<	poolBlocked.countDown();
741	<	assertTrue(unblock.await(LONG_DELAY_MS, MILLISECONDS));
742	<	ran.getAndIncrement();
743	<	}};
744	<	List<Future<?>> blockers = new ArrayList<>();
745	<	List<Future<?>> periodics = new ArrayList<>();
746	<	List<Future<?>> delayeds = new ArrayList<>();
747	<	for (int i = 0; i < poolSize; i++)
748	<	blockers.add(p.submit(task));
749	<	assertTrue(poolBlocked.await(LONG_DELAY_MS, MILLISECONDS));
750	<
751	<	periodics.add(p.scheduleAtFixedRate(countDowner(periodicLatch1),
752	<	1, 1, MILLISECONDS));
753	<	periodics.add(p.scheduleWithFixedDelay(countDowner(periodicLatch2),
754	<	1, 1, MILLISECONDS));
755	<	delayeds.add(p.schedule(task, 1, MILLISECONDS));
793	>	final RuntimeException exception = new RuntimeException();
794
795	<	assertTrue(p.getQueue().containsAll(periodics));
796	<	assertTrue(p.getQueue().containsAll(delayeds));
797	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
798	<	assertTrue(p.isShutdown());
799	<	assertFalse(p.isTerminated());
800	<	for (Future<?> periodic : periodics) {
801	<	assertTrue(effectivePeriodicPolicy ^ periodic.isCancelled());
764	<	assertTrue(effectivePeriodicPolicy ^ periodic.isDone());
765	<	}
766	<	for (Future<?> delayed : delayeds) {
767	<	assertTrue(effectiveDelayedPolicy ^ delayed.isCancelled());
768	<	assertTrue(effectiveDelayedPolicy ^ delayed.isDone());
769	<	}
770	<	if (testImplementationDetails) {
771	<	assertEquals(effectivePeriodicPolicy,
772	<	p.getQueue().containsAll(periodics));
773	<	assertEquals(effectiveDelayedPolicy,
774	<	p.getQueue().containsAll(delayeds));
775	<	}
776	<	// Release all pool threads
777	<	unblock.countDown();
778	<
779	<	for (Future<?> delayed : delayeds) {
780	<	if (effectiveDelayedPolicy) {
781	<	assertNull(delayed.get());
795	>	class Task implements Runnable {
796	>	public void run() {
797	>	try {
798	>	ran.getAndIncrement();
799	>	poolBlocked.countDown();
800	>	await(unblock);
801	>	} catch (Throwable fail) { threadUnexpectedException(fail); }
802		}
803		}
804	<	if (effectivePeriodicPolicy) {
805	<	assertTrue(periodicLatch1.await(LONG_DELAY_MS, MILLISECONDS));
806	<	assertTrue(periodicLatch2.await(LONG_DELAY_MS, MILLISECONDS));
807	<	for (Future<?> periodic : periodics) {
808	<	assertTrue(periodic.cancel(false));
809	<	assertTrue(periodic.isCancelled());
810	<	assertTrue(periodic.isDone());
804	>
805	>	class PeriodicTask extends Task {
806	>	PeriodicTask(int rounds) { this.rounds = rounds; }
807	>	int rounds;
808	>	public void run() {
809	>	if (--rounds == 0) super.run();
810	>	// throw exception to surely terminate this periodic task,
811	>	// but in a separate execution and in a detectable way.
812	>	if (rounds == -1) throw exception;
813		}
814		}
815	+
816	+	Runnable task = new Task();
817	+
818	+	List<Future<?>> immediates = new ArrayList<>();
819	+	List<Future<?>> delayeds   = new ArrayList<>();
820	+	List<Future<?>> periodics  = new ArrayList<>();
821	+
822	+	immediates.add(p.submit(task));
823	+	delayeds.add(p.schedule(task, delay, MILLISECONDS));
824	+	periodics.add(p.scheduleAtFixedRate(
825	+	new PeriodicTask(rounds), delay, 1, MILLISECONDS));
826	+	periodics.add(p.scheduleWithFixedDelay(
827	+	new PeriodicTask(rounds), delay, 1, MILLISECONDS));
828	+
829	+	await(poolBlocked);
830	+
831	+	assertEquals(poolSize, ran.get());
832	+	assertEquals(poolSize, p.getActiveCount());
833	+	assertTrue(q.isEmpty());
834	+
835	+	// Add second wave of tasks.
836	+	immediates.add(p.submit(task));
837	+	delayeds.add(p.schedule(task, effectiveDelayedPolicy ? delay : LONG_DELAY_MS, MILLISECONDS));
838	+	periodics.add(p.scheduleAtFixedRate(
839	+	new PeriodicTask(rounds), delay, 1, MILLISECONDS));
840	+	periodics.add(p.scheduleWithFixedDelay(
841	+	new PeriodicTask(rounds), delay, 1, MILLISECONDS));
842	+
843	+	assertEquals(poolSize, q.size());
844	+	assertEquals(poolSize, ran.get());
845	+
846	+	immediates.forEach(
847	+	f -> assertTrue(((ScheduledFuture)f).getDelay(NANOSECONDS) <= 0L));
848	+
849	+	Stream.of(immediates, delayeds, periodics).flatMap(c -> c.stream())
850	+	.forEach(f -> assertFalse(f.isDone()));
851	+
852	+	try { p.shutdown(); } catch (SecurityException ok) { return; }
853	+	assertTrue(p.isShutdown());
854	+	assertTrue(p.isTerminating());
855	+	assertFalse(p.isTerminated());
856	+
857	+	if (rnd.nextBoolean())
858	+	assertThrows(
859	+	RejectedExecutionException.class,
860	+	() -> p.submit(task),
861	+	() -> p.schedule(task, 1, SECONDS),
862	+	() -> p.scheduleAtFixedRate(
863	+	new PeriodicTask(1), 1, 1, SECONDS),
864	+	() -> p.scheduleWithFixedDelay(
865	+	new PeriodicTask(2), 1, 1, SECONDS));
866	+
867	+	assertTrue(q.contains(immediates.get(1)));
868	+	assertTrue(!effectiveDelayedPolicy
869	+	^ q.contains(delayeds.get(1)));
870	+	assertTrue(!effectivePeriodicPolicy
871	+	^ q.containsAll(periodics.subList(2, 4)));
872	+
873	+	immediates.forEach(f -> assertFalse(f.isDone()));
874	+
875	+	assertFalse(delayeds.get(0).isDone());
876	+	if (effectiveDelayedPolicy)
877	+	assertFalse(delayeds.get(1).isDone());
878	+	else
879	+	assertTrue(delayeds.get(1).isCancelled());
880	+
881	+	if (effectivePeriodicPolicy)
882	+	periodics.forEach(
883	+	f -> {
884	+	assertFalse(f.isDone());
885	+	if (!periodicTasksContinue) {
886	+	assertTrue(f.cancel(false));
887	+	assertTrue(f.isCancelled());
888	+	}
889	+	});
890	+	else {
891	+	periodics.subList(0, 2).forEach(f -> assertFalse(f.isDone()));
892	+	periodics.subList(2, 4).forEach(f -> assertTrue(f.isCancelled()));
893	+	}
894	+
895	+	unblock.countDown();    // Release all pool threads
896	+
897		assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
898	+	assertFalse(p.isTerminating());
899		assertTrue(p.isTerminated());
900	<	assertEquals(2 + (effectiveDelayedPolicy ? 1 : 0), ran.get());
901	<	}}
900	>
901	>	assertTrue(q.isEmpty());
902	>
903	>	Stream.of(immediates, delayeds, periodics).flatMap(c -> c.stream())
904	>	.forEach(f -> assertTrue(f.isDone()));
905	>
906	>	for (Future<?> f : immediates) assertNull(f.get());
907	>
908	>	assertNull(delayeds.get(0).get());
909	>	if (effectiveDelayedPolicy)
910	>	assertNull(delayeds.get(1).get());
911	>	else
912	>	assertTrue(delayeds.get(1).isCancelled());
913	>
914	>	if (periodicTasksContinue)
915	>	periodics.forEach(
916	>	f -> {
917	>	try { f.get(); }
918	>	catch (ExecutionException success) {
919	>	assertSame(exception, success.getCause());
920	>	}
921	>	catch (Throwable fail) { threadUnexpectedException(fail); }
922	>	});
923	>	else
924	>	periodics.forEach(f -> assertTrue(f.isCancelled()));
925	>
926	>	assertEquals(poolSize + 1
927	>	+ (effectiveDelayedPolicy ? 1 : 0)
928	>	+ (periodicTasksContinue ? 2 : 0),
929	>	ran.get());
930	>	}
931
932		/**
933		* completed submit of callable returns result
#	Line 832 | Line 966 | public class ScheduledExecutorTest exten
966		}
967
968		/**
969	<	* invokeAny(null) throws NPE
969	>	* invokeAny(null) throws NullPointerException
970		*/
971		public void testInvokeAny1() throws Exception {
972		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
#	Line 845 | Line 979 | public class ScheduledExecutorTest exten
979		}
980
981		/**
982	<	* invokeAny(empty collection) throws IAE
982	>	* invokeAny(empty collection) throws IllegalArgumentException
983		*/
984		public void testInvokeAny2() throws Exception {
985		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
#	Line 858 | Line 992 | public class ScheduledExecutorTest exten
992		}
993
994		/**
995	<	* invokeAny(c) throws NPE if c has null elements
995	>	* invokeAny(c) throws NullPointerException if c has null elements
996		*/
997		public void testInvokeAny3() throws Exception {
998		CountDownLatch latch = new CountDownLatch(1);
999		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1000		try (PoolCleaner cleaner = cleaner(e)) {
1001	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1001	>	List<Callable<String>> l = new ArrayList<>();
1002		l.add(latchAwaitingStringTask(latch));
1003		l.add(null);
1004		try {
#	Line 881 | Line 1015 | public class ScheduledExecutorTest exten
1015		public void testInvokeAny4() throws Exception {
1016		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1017		try (PoolCleaner cleaner = cleaner(e)) {
1018	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1018	>	List<Callable<String>> l = new ArrayList<>();
1019		l.add(new NPETask());
1020		try {
1021		e.invokeAny(l);
#	Line 898 | Line 1032 | public class ScheduledExecutorTest exten
1032		public void testInvokeAny5() throws Exception {
1033		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1034		try (PoolCleaner cleaner = cleaner(e)) {
1035	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1035	>	List<Callable<String>> l = new ArrayList<>();
1036		l.add(new StringTask());
1037		l.add(new StringTask());
1038		String result = e.invokeAny(l);
#	Line 920 | Line 1054 | public class ScheduledExecutorTest exten
1054		}
1055
1056		/**
1057	<	* invokeAll(empty collection) returns empty collection
1057	>	* invokeAll(empty collection) returns empty list
1058		*/
1059		public void testInvokeAll2() throws Exception {
1060		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1061	+	final Collection<Callable<String>> emptyCollection
1062	+	= Collections.emptyList();
1063		try (PoolCleaner cleaner = cleaner(e)) {
1064	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1064	>	List<Future<String>> r = e.invokeAll(emptyCollection);
1065		assertTrue(r.isEmpty());
1066		}
1067		}
#	Line 936 | Line 1072 | public class ScheduledExecutorTest exten
1072		public void testInvokeAll3() throws Exception {
1073		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1074		try (PoolCleaner cleaner = cleaner(e)) {
1075	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1075	>	List<Callable<String>> l = new ArrayList<>();
1076		l.add(new StringTask());
1077		l.add(null);
1078		try {
#	Line 952 | Line 1088 | public class ScheduledExecutorTest exten
1088		public void testInvokeAll4() throws Exception {
1089		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1090		try (PoolCleaner cleaner = cleaner(e)) {
1091	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1091	>	List<Callable<String>> l = new ArrayList<>();
1092		l.add(new NPETask());
1093		List<Future<String>> futures = e.invokeAll(l);
1094		assertEquals(1, futures.size());
#	Line 971 | Line 1107 | public class ScheduledExecutorTest exten
1107		public void testInvokeAll5() throws Exception {
1108		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1109		try (PoolCleaner cleaner = cleaner(e)) {
1110	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1110	>	List<Callable<String>> l = new ArrayList<>();
1111		l.add(new StringTask());
1112		l.add(new StringTask());
1113		List<Future<String>> futures = e.invokeAll(l);
#	Line 988 | Line 1124 | public class ScheduledExecutorTest exten
1124		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1125		try (PoolCleaner cleaner = cleaner(e)) {
1126		try {
1127	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1127	>	e.invokeAny(null, randomTimeout(), randomTimeUnit());
1128		shouldThrow();
1129		} catch (NullPointerException success) {}
1130		}
1131		}
1132
1133		/**
1134	<	* timed invokeAny(,,null) throws NPE
1134	>	* timed invokeAny(,,null) throws NullPointerException
1135		*/
1136		public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1137		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1138		try (PoolCleaner cleaner = cleaner(e)) {
1139	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1139	>	List<Callable<String>> l = new ArrayList<>();
1140		l.add(new StringTask());
1141		try {
1142	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1142	>	e.invokeAny(l, randomTimeout(), null);
1143		shouldThrow();
1144		} catch (NullPointerException success) {}
1145		}
1146		}
1147
1148		/**
1149	<	* timed invokeAny(empty collection) throws IAE
1149	>	* timed invokeAny(empty collection) throws IllegalArgumentException
1150		*/
1151		public void testTimedInvokeAny2() throws Exception {
1152		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1153	+	final Collection<Callable<String>> emptyCollection
1154	+	= Collections.emptyList();
1155		try (PoolCleaner cleaner = cleaner(e)) {
1156		try {
1157	<	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1157	>	e.invokeAny(emptyCollection, randomTimeout(), randomTimeUnit());
1158		shouldThrow();
1159		} catch (IllegalArgumentException success) {}
1160		}
#	Line 1029 | Line 1167 | public class ScheduledExecutorTest exten
1167		CountDownLatch latch = new CountDownLatch(1);
1168		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1169		try (PoolCleaner cleaner = cleaner(e)) {
1170	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1170	>	List<Callable<String>> l = new ArrayList<>();
1171		l.add(latchAwaitingStringTask(latch));
1172		l.add(null);
1173		try {
1174	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1174	>	e.invokeAny(l, randomTimeout(), randomTimeUnit());
1175		shouldThrow();
1176		} catch (NullPointerException success) {}
1177		latch.countDown();
#	Line 1047 | Line 1185 | public class ScheduledExecutorTest exten
1185		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1186		try (PoolCleaner cleaner = cleaner(e)) {
1187		long startTime = System.nanoTime();
1188	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1188	>	List<Callable<String>> l = new ArrayList<>();
1189		l.add(new NPETask());
1190		try {
1191		e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1066 | Line 1204 | public class ScheduledExecutorTest exten
1204		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1205		try (PoolCleaner cleaner = cleaner(e)) {
1206		long startTime = System.nanoTime();
1207	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1207	>	List<Callable<String>> l = new ArrayList<>();
1208		l.add(new StringTask());
1209		l.add(new StringTask());
1210		String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1082 | Line 1220 | public class ScheduledExecutorTest exten
1220		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1221		try (PoolCleaner cleaner = cleaner(e)) {
1222		try {
1223	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1223	>	e.invokeAll(null, randomTimeout(), randomTimeUnit());
1224		shouldThrow();
1225		} catch (NullPointerException success) {}
1226		}
#	Line 1094 | Line 1232 | public class ScheduledExecutorTest exten
1232		public void testTimedInvokeAllNullTimeUnit() throws Exception {
1233		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1234		try (PoolCleaner cleaner = cleaner(e)) {
1235	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1235	>	List<Callable<String>> l = new ArrayList<>();
1236		l.add(new StringTask());
1237		try {
1238	<	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1238	>	e.invokeAll(l, randomTimeout(), null);
1239		shouldThrow();
1240		} catch (NullPointerException success) {}
1241		}
1242		}
1243
1244		/**
1245	<	* timed invokeAll(empty collection) returns empty collection
1245	>	* timed invokeAll(empty collection) returns empty list
1246		*/
1247		public void testTimedInvokeAll2() throws Exception {
1248		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1249	+	final Collection<Callable<String>> emptyCollection
1250	+	= Collections.emptyList();
1251		try (PoolCleaner cleaner = cleaner(e)) {
1252	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1253	<	MEDIUM_DELAY_MS, MILLISECONDS);
1252	>	List<Future<String>> r =
1253	>	e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1254		assertTrue(r.isEmpty());
1255		}
1256		}
#	Line 1121 | Line 1261 | public class ScheduledExecutorTest exten
1261		public void testTimedInvokeAll3() throws Exception {
1262		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1263		try (PoolCleaner cleaner = cleaner(e)) {
1264	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1264	>	List<Callable<String>> l = new ArrayList<>();
1265		l.add(new StringTask());
1266		l.add(null);
1267		try {
1268	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1268	>	e.invokeAll(l, randomTimeout(), randomTimeUnit());
1269		shouldThrow();
1270		} catch (NullPointerException success) {}
1271		}
#	Line 1137 | Line 1277 | public class ScheduledExecutorTest exten
1277		public void testTimedInvokeAll4() throws Exception {
1278		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1279		try (PoolCleaner cleaner = cleaner(e)) {
1280	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1280	>	List<Callable<String>> l = new ArrayList<>();
1281		l.add(new NPETask());
1282		List<Future<String>> futures =
1283		e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1157 | Line 1297 | public class ScheduledExecutorTest exten
1297		public void testTimedInvokeAll5() throws Exception {
1298		final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1299		try (PoolCleaner cleaner = cleaner(e)) {
1300	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1300	>	List<Callable<String>> l = new ArrayList<>();
1301		l.add(new StringTask());
1302		l.add(new StringTask());
1303		List<Future<String>> futures =
#	Line 1206 | Line 1346 | public class ScheduledExecutorTest exten
1346		}
1347		}
1348
1349	+	/**
1350	+	* A fixed delay task with overflowing period should not prevent a
1351	+	* one-shot task from executing.
1352	+	* https://bugs.openjdk.java.net/browse/JDK-8051859
1353	+	*/
1354	+	public void testScheduleWithFixedDelay_overflow() throws Exception {
1355	+	final CountDownLatch delayedDone = new CountDownLatch(1);
1356	+	final CountDownLatch immediateDone = new CountDownLatch(1);
1357	+	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
1358	+	try (PoolCleaner cleaner = cleaner(p)) {
1359	+	final Runnable immediate = new Runnable() { public void run() {
1360	+	immediateDone.countDown();
1361	+	}};
1362	+	final Runnable delayed = new Runnable() { public void run() {
1363	+	delayedDone.countDown();
1364	+	p.submit(immediate);
1365	+	}};
1366	+	p.scheduleWithFixedDelay(delayed, 0L, Long.MAX_VALUE, SECONDS);
1367	+	await(delayedDone);
1368	+	await(immediateDone);
1369	+	}
1370	+	}
1371	+
1372		}

Diff Legend

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