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.86 by jsr166, Sat Mar 25 21:41:10 2017 UTC vs.
Revision 1.89 by jsr166, Tue Mar 28 18:13:10 2017 UTC

#	Line 24 | Line 24 | import java.util.concurrent.RejectedExec
24		import java.util.concurrent.ScheduledFuture;
25		import java.util.concurrent.ScheduledThreadPoolExecutor;
26		import java.util.concurrent.ThreadFactory;
27	+	import java.util.concurrent.ThreadLocalRandom;
28		import java.util.concurrent.ThreadPoolExecutor;
29		import java.util.concurrent.atomic.AtomicBoolean;
30		import java.util.concurrent.atomic.AtomicInteger;
31		import java.util.concurrent.atomic.AtomicLong;
32	+	import java.util.stream.Stream;
33
34		import junit.framework.Test;
35		import junit.framework.TestSuite;
#	Line 744 | Line 746 | public class ScheduledExecutorTest exten
746		* - setContinueExistingPeriodicTasksAfterShutdownPolicy
747		*/
748		public void testShutdown_cancellation() throws Exception {
749	<	Boolean[] allBooleans = { null, Boolean.FALSE, Boolean.TRUE };
748	<	for (Boolean policy : allBooleans)
749	<	{
750	<	final int poolSize = 2;
749	>	final int poolSize = 6;
750		final ScheduledThreadPoolExecutor p
751		= new ScheduledThreadPoolExecutor(poolSize);
752	<	final boolean effectiveDelayedPolicy = (policy != Boolean.FALSE);
753	<	final boolean effectivePeriodicPolicy = (policy == Boolean.TRUE);
754	<	final boolean effectiveRemovePolicy = (policy == Boolean.TRUE);
755	<	if (policy != null) {
756	<	p.setExecuteExistingDelayedTasksAfterShutdownPolicy(policy);
757	<	p.setContinueExistingPeriodicTasksAfterShutdownPolicy(policy);
758	<	p.setRemoveOnCancelPolicy(policy);
759	<	}
752	>	final BlockingQueue<Runnable> q = p.getQueue();
753	>	final ThreadLocalRandom rnd = ThreadLocalRandom.current();
754	>	final boolean effectiveDelayedPolicy;
755	>	final boolean effectivePeriodicPolicy;
756	>	final boolean effectiveRemovePolicy;
757	>
758	>	if (rnd.nextBoolean())
759	>	p.setExecuteExistingDelayedTasksAfterShutdownPolicy(
760	>	effectiveDelayedPolicy = rnd.nextBoolean());
761	>	else
762	>	effectiveDelayedPolicy = true;
763		assertEquals(effectiveDelayedPolicy,
764		p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
765	+
766	+	if (rnd.nextBoolean())
767	+	p.setContinueExistingPeriodicTasksAfterShutdownPolicy(
768	+	effectivePeriodicPolicy = rnd.nextBoolean());
769	+	else
770	+	effectivePeriodicPolicy = false;
771		assertEquals(effectivePeriodicPolicy,
772		p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
773	+
774	+	if (rnd.nextBoolean())
775	+	p.setRemoveOnCancelPolicy(
776	+	effectiveRemovePolicy = rnd.nextBoolean());
777	+	else
778	+	effectiveRemovePolicy = false;
779		assertEquals(effectiveRemovePolicy,
780		p.getRemoveOnCancelPolicy());
781	<	// Strategy: Wedge the pool with poolSize "blocker" threads
781	>
782	>	// System.err.println("effectiveDelayedPolicy="+effectiveDelayedPolicy);
783	>	// System.err.println("effectivePeriodicPolicy="+effectivePeriodicPolicy);
784	>	// System.err.println("effectiveRemovePolicy="+effectiveRemovePolicy);
785	>
786	>	// Strategy: Wedge the pool with one wave of "blocker" tasks,
787	>	// then add a second wave that waits in the queue.
788		final AtomicInteger ran = new AtomicInteger(0);
789		final CountDownLatch poolBlocked = new CountDownLatch(poolSize);
790		final CountDownLatch unblock = new CountDownLatch(1);
771	–	final CountDownLatch periodicLatch1 = new CountDownLatch(2);
772	–	final CountDownLatch periodicLatch2 = new CountDownLatch(2);
773	–	Runnable task = new CheckedRunnable() { public void realRun()
774	–	throws InterruptedException {
775	–	poolBlocked.countDown();
776	–	await(unblock);
777	–	ran.getAndIncrement();
778	–	}};
779	–	List<Future<?>> blockers = new ArrayList<>();
780	–	List<Future<?>> periodics = new ArrayList<>();
781	–	List<Future<?>> delayeds = new ArrayList<>();
782	–	for (int i = 0; i < poolSize; i++)
783	–	blockers.add(p.submit(task));
784	–	await(poolBlocked);
791
792	<	periodics.add(p.scheduleAtFixedRate(countDowner(periodicLatch1),
793	<	1, 1, MILLISECONDS));
794	<	periodics.add(p.scheduleWithFixedDelay(countDowner(periodicLatch2),
795	<	1, 1, MILLISECONDS));
792	>	class Task extends CheckedRunnable {
793	>	public void realRun() throws InterruptedException {
794	>	ran.getAndIncrement();
795	>	poolBlocked.countDown();
796	>	await(unblock);
797	>	}
798	>	}
799	>
800	>	class PeriodicTask extends Task {
801	>	PeriodicTask(int rounds) { this.rounds = rounds; }
802	>	int rounds;
803	>	public void realRun() throws InterruptedException {
804	>	if (--rounds == 0) super.realRun();
805	>	}
806	>	}
807	>
808	>	Runnable task = new Task();
809	>
810	>	List<Future<?>> immediates = new ArrayList<>();
811	>	List<Future<?>> delayeds   = new ArrayList<>();
812	>	List<Future<?>> periodics  = new ArrayList<>();
813	>
814	>	immediates.add(p.submit(task));
815		delayeds.add(p.schedule(task, 1, MILLISECONDS));
816	+	for (int rounds : new int[] { 1, 2 }) {
817	+	periodics.add(p.scheduleAtFixedRate(
818	+	new PeriodicTask(rounds), 1, 1, MILLISECONDS));
819	+	periodics.add(p.scheduleWithFixedDelay(
820	+	new PeriodicTask(rounds), 1, 1, MILLISECONDS));
821	+	}
822	+
823	+	await(poolBlocked);
824	+
825	+	assertEquals(poolSize, ran.get());
826	+	assertTrue(q.isEmpty());
827	+
828	+	// Add second wave of tasks.
829	+	immediates.add(p.submit(task));
830	+	long delay_ms = effectiveDelayedPolicy ? 1 : LONG_DELAY_MS;
831	+	delayeds.add(p.schedule(task, delay_ms, MILLISECONDS));
832	+	for (int rounds : new int[] { 1, 2 }) {
833	+	periodics.add(p.scheduleAtFixedRate(
834	+	new PeriodicTask(rounds), 1, 1, MILLISECONDS));
835	+	periodics.add(p.scheduleWithFixedDelay(
836	+	new PeriodicTask(rounds), 1, 1, MILLISECONDS));
837	+	}
838	+
839	+	assertEquals(poolSize, q.size());
840	+	assertEquals(poolSize, ran.get());
841	+
842	+	immediates.forEach(
843	+	f -> assertTrue(((ScheduledFuture)f).getDelay(NANOSECONDS) <= 0L));
844	+
845	+	Stream.of(immediates, delayeds, periodics).flatMap(c -> c.stream())
846	+	.forEach(f -> assertFalse(f.isDone()));
847
792	–	assertTrue(p.getQueue().containsAll(periodics));
793	–	assertTrue(p.getQueue().containsAll(delayeds));
848		try { p.shutdown(); } catch (SecurityException ok) { return; }
849		assertTrue(p.isShutdown());
850	+	assertTrue(p.isTerminating());
851		assertFalse(p.isTerminated());
852	<	for (Future<?> periodic : periodics) {
853	<	assertTrue(effectivePeriodicPolicy ^ periodic.isCancelled());
854	<	assertTrue(effectivePeriodicPolicy ^ periodic.isDone());
855	<	}
856	<	for (Future<?> delayed : delayeds) {
857	<	assertTrue(effectiveDelayedPolicy ^ delayed.isCancelled());
858	<	assertTrue(effectiveDelayedPolicy ^ delayed.isDone());
859	<	}
852	>
853	>	if (rnd.nextBoolean())
854	>	assertThrows(
855	>	RejectedExecutionException.class,
856	>	() -> p.submit(task),
857	>	() -> p.schedule(task, 1, SECONDS),
858	>	() -> p.scheduleAtFixedRate(
859	>	new PeriodicTask(1), 1, 1, SECONDS),
860	>	() -> p.scheduleWithFixedDelay(
861	>	new PeriodicTask(2), 1, 1, SECONDS));
862	>
863	>	assertTrue(q.contains(immediates.get(1)));
864	>	assertTrue(!effectiveDelayedPolicy
865	>	^ q.contains(delayeds.get(1)));
866	>	assertTrue(!effectivePeriodicPolicy
867	>	^ q.containsAll(periodics.subList(4, 8)));
868	>
869	>	immediates.forEach(f -> assertFalse(f.isDone()));
870	>
871	>	assertFalse(delayeds.get(0).isDone());
872	>	if (effectiveDelayedPolicy)
873	>	assertFalse(delayeds.get(1).isDone());
874	>	else
875	>	assertTrue(delayeds.get(1).isCancelled());
876	>
877		if (testImplementationDetails) {
878	<	assertEquals(effectivePeriodicPolicy,
879	<	p.getQueue().containsAll(periodics));
880	<	assertEquals(effectiveDelayedPolicy,
881	<	p.getQueue().containsAll(delayeds));
882	<	}
883	<	// Release all pool threads
884	<	unblock.countDown();
885	<
886	<	for (Future<?> delayed : delayeds) {
887	<	if (effectiveDelayedPolicy) {
816	<	assertNull(delayed.get());
878	>	if (effectivePeriodicPolicy)
879	>	// TODO: ensure periodic tasks continue executing
880	>	periodics.forEach(
881	>	f -> {
882	>	assertFalse(f.isDone());
883	>	assertTrue(f.cancel(false));
884	>	});
885	>	else {
886	>	periodics.subList(0, 4).forEach(f -> assertFalse(f.isDone()));
887	>	periodics.subList(4, 8).forEach(f -> assertTrue(f.isCancelled()));
888		}
889		}
890	<	if (effectivePeriodicPolicy) {
891	<	await(periodicLatch1);
892	<	await(periodicLatch2);
822	<	for (Future<?> periodic : periodics) {
823	<	assertTrue(periodic.cancel(false));
824	<	assertTrue(periodic.isCancelled());
825	<	assertTrue(periodic.isDone());
826	<	}
827	<	}
828	<	for (Future<?> blocker : blockers) assertNull(blocker.get());
890	>
891	>	unblock.countDown();    // Release all pool threads
892	>
893		assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
894	+	assertFalse(p.isTerminating());
895		assertTrue(p.isTerminated());
896	<	assertEquals(2 + (effectiveDelayedPolicy ? 1 : 0), ran.get());
897	<	}}
896	>
897	>	assertTrue(q.isEmpty());
898	>
899	>	for (Future<?> f : immediates) assertNull(f.get());
900	>
901	>	assertNull(delayeds.get(0).get());
902	>	if (effectiveDelayedPolicy)
903	>	assertNull(delayeds.get(1).get());
904	>	else
905	>	assertTrue(delayeds.get(1).isCancelled());
906	>
907	>	periodics.forEach(f -> assertTrue(f.isDone()));
908	>	periodics.forEach(f -> assertTrue(f.isCancelled()));
909	>
910	>	assertEquals(poolSize + 1 + (effectiveDelayedPolicy ? 1 : 0), ran.get());
911	>	}
912
913		/**
914		* completed submit of callable returns result

Diff Legend

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