ViewVC Help

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

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

Comparing jsr166/src/test/tck/ScheduledExecutorSubclassTest.java (file contents):
Revision 1.19 by jsr166, Tue Mar 15 19:47:07 2011 UTC vs.
Revision 1.33 by jsr166, Wed Sep 25 07:39:17 2013 UTC

#	Line 8 | Line 8 | import junit.framework.*;
8		import java.util.*;
9		import java.util.concurrent.*;
10		import static java.util.concurrent.TimeUnit.MILLISECONDS;
11	<	import java.util.concurrent.atomic.*;
11	>	import java.util.concurrent.atomic.AtomicInteger;
12
13		public class ScheduledExecutorSubclassTest extends JSR166TestCase {
14		public static void main(String[] args) {
#	Line 36 | Line 36 | public class ScheduledExecutorSubclassTe
36		}
37		public boolean isCancelled() { return task.isCancelled(); }
38		public boolean isDone() { return task.isDone(); }
39	<	public V get() throws InterruptedException,  ExecutionException {
39	>	public V get() throws InterruptedException, ExecutionException {
40		V v = task.get();
41		assertTrue(ran);
42		return v;
43		}
44	<	public V get(long time, TimeUnit unit) throws InterruptedException,  ExecutionException, TimeoutException {
44	>	public V get(long time, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
45		V v = task.get(time, unit);
46		assertTrue(ran);
47		return v;
48		}
49		}
50
51	–
51		public class CustomExecutor extends ScheduledThreadPoolExecutor {
52
53		protected <V> RunnableScheduledFuture<V> decorateTask(Runnable r, RunnableScheduledFuture<V> task) {
#	Line 58 | Line 57 | public class ScheduledExecutorSubclassTe
57		protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> c, RunnableScheduledFuture<V> task) {
58		return new CustomTask<V>(task);
59		}
60	<	CustomExecutor(int corePoolSize) { super(corePoolSize);}
60	>	CustomExecutor(int corePoolSize) { super(corePoolSize); }
61		CustomExecutor(int corePoolSize, RejectedExecutionHandler handler) {
62		super(corePoolSize, handler);
63		}
#	Line 73 | Line 72 | public class ScheduledExecutorSubclassTe
72
73		}
74
76	–
75		/**
76		* execute successfully executes a runnable
77		*/
#	Line 92 | Line 90 | public class ScheduledExecutorSubclassTe
90		}
91		}
92
95	–
93		/**
94		* delayed schedule of callable successfully executes after delay
95		*/
96		public void testSchedule1() throws Exception {
97		CustomExecutor p = new CustomExecutor(1);
98	<	final long t0 = System.nanoTime();
102	<	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
98	>	final long startTime = System.nanoTime();
99		final CountDownLatch done = new CountDownLatch(1);
100		try {
101		Callable task = new CheckedCallable<Boolean>() {
102		public Boolean realCall() {
103		done.countDown();
104	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
104	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
105		return Boolean.TRUE;
106		}};
107	<	Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
108	<	assertEquals(Boolean.TRUE, f.get());
109	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
107	>	Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
108	>	assertSame(Boolean.TRUE, f.get());
109	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
110		assertTrue(done.await(0L, MILLISECONDS));
111		} finally {
112		joinPool(p);
#	Line 122 | Line 118 | public class ScheduledExecutorSubclassTe
118		*/
119		public void testSchedule3() throws Exception {
120		CustomExecutor p = new CustomExecutor(1);
121	<	final long t0 = System.nanoTime();
126	<	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
121	>	final long startTime = System.nanoTime();
122		final CountDownLatch done = new CountDownLatch(1);
123		try {
124		Runnable task = new CheckedRunnable() {
125		public void realRun() {
126		done.countDown();
127	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
127	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
128		}};
129	<	Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
130	<	assertNull(f.get());
131	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
132	<	assertTrue(done.await(0L, MILLISECONDS));
129	>	Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
130	>	await(done);
131	>	assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
132	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
133		} finally {
134		joinPool(p);
135		}
#	Line 145 | Line 140 | public class ScheduledExecutorSubclassTe
140		*/
141		public void testSchedule4() throws InterruptedException {
142		CustomExecutor p = new CustomExecutor(1);
143	<	final long t0 = System.nanoTime();
149	<	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
143	>	final long startTime = System.nanoTime();
144		final CountDownLatch done = new CountDownLatch(1);
145		try {
146		Runnable task = new CheckedRunnable() {
147		public void realRun() {
148		done.countDown();
149	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
149	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
150		}};
151		ScheduledFuture f =
152	<	p.scheduleAtFixedRate(task, SHORT_DELAY_MS,
153	<	SHORT_DELAY_MS, MILLISECONDS);
154	<	assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
155	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
152	>	p.scheduleAtFixedRate(task, timeoutMillis(),
153	>	LONG_DELAY_MS, MILLISECONDS);
154	>	await(done);
155	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
156		f.cancel(true);
157		} finally {
158		joinPool(p);
#	Line 170 | Line 164 | public class ScheduledExecutorSubclassTe
164		*/
165		public void testSchedule5() throws InterruptedException {
166		CustomExecutor p = new CustomExecutor(1);
167	<	final long t0 = System.nanoTime();
174	<	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
167	>	final long startTime = System.nanoTime();
168		final CountDownLatch done = new CountDownLatch(1);
169		try {
170		Runnable task = new CheckedRunnable() {
171		public void realRun() {
172		done.countDown();
173	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
173	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
174		}};
175		ScheduledFuture f =
176	<	p.scheduleWithFixedDelay(task, SHORT_DELAY_MS,
177	<	SHORT_DELAY_MS, MILLISECONDS);
178	<	assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
179	<	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
176	>	p.scheduleWithFixedDelay(task, timeoutMillis(),
177	>	LONG_DELAY_MS, MILLISECONDS);
178	>	await(done);
179	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
180		f.cancel(true);
181		} finally {
182		joinPool(p);
#	Line 200 | Line 193 | public class ScheduledExecutorSubclassTe
193		*/
194		public void testFixedRateSequence() throws InterruptedException {
195		CustomExecutor p = new CustomExecutor(1);
196	<	RunnableCounter counter = new RunnableCounter();
197	<	ScheduledFuture h =
198	<	p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
199	<	Thread.sleep(SMALL_DELAY_MS);
200	<	h.cancel(true);
201	<	int c = counter.count.get();
202	<	// By time scaling conventions, we must have at least
203	<	// an execution per SHORT delay, but no more than one SHORT more
204	<	assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
205	<	assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
206	<	joinPool(p);
196	>	try {
197	>	for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
198	>	long startTime = System.nanoTime();
199	>	int cycles = 10;
200	>	final CountDownLatch done = new CountDownLatch(cycles);
201	>	Runnable task = new CheckedRunnable() {
202	>	public void realRun() { done.countDown(); }};
203	>	ScheduledFuture h =
204	>	p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
205	>	done.await();
206	>	h.cancel(true);
207	>	double normalizedTime =
208	>	(double) millisElapsedSince(startTime) / delay;
209	>	if (normalizedTime >= cycles - 1 &&
210	>	normalizedTime <= cycles)
211	>	return;
212	>	}
213	>	throw new AssertionError("unexpected execution rate");
214	>	} finally {
215	>	joinPool(p);
216	>	}
217		}
218
219		/**
#	Line 218 | Line 221 | public class ScheduledExecutorSubclassTe
221		*/
222		public void testFixedDelaySequence() throws InterruptedException {
223		CustomExecutor p = new CustomExecutor(1);
224	<	RunnableCounter counter = new RunnableCounter();
225	<	ScheduledFuture h =
226	<	p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
227	<	Thread.sleep(SMALL_DELAY_MS);
228	<	h.cancel(true);
229	<	int c = counter.count.get();
230	<	assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
231	<	assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
232	<	joinPool(p);
224	>	try {
225	>	for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
226	>	long startTime = System.nanoTime();
227	>	int cycles = 10;
228	>	final CountDownLatch done = new CountDownLatch(cycles);
229	>	Runnable task = new CheckedRunnable() {
230	>	public void realRun() { done.countDown(); }};
231	>	ScheduledFuture h =
232	>	p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
233	>	done.await();
234	>	h.cancel(true);
235	>	double normalizedTime =
236	>	(double) millisElapsedSince(startTime) / delay;
237	>	if (normalizedTime >= cycles - 1 &&
238	>	normalizedTime <= cycles)
239	>	return;
240	>	}
241	>	throw new AssertionError("unexpected execution rate");
242	>	} finally {
243	>	joinPool(p);
244	>	}
245		}
246
232	–
247		/**
248		* execute(null) throws NPE
249		*/
#	Line 291 | Line 305 | public class ScheduledExecutorSubclassTe
305		/**
306		* schedule callable throws RejectedExecutionException if shutdown
307		*/
308	<	public void testSchedule3_RejectedExecutionException() {
309	<	CustomExecutor se = new CustomExecutor(1);
310	<	try {
311	<	se.shutdown();
312	<	se.schedule(new NoOpCallable(),
313	<	MEDIUM_DELAY_MS, MILLISECONDS);
314	<	shouldThrow();
315	<	} catch (RejectedExecutionException success) {
316	<	} catch (SecurityException ok) {
317	<	}
318	<	joinPool(se);
308	>	public void testSchedule3_RejectedExecutionException() {
309	>	CustomExecutor se = new CustomExecutor(1);
310	>	try {
311	>	se.shutdown();
312	>	se.schedule(new NoOpCallable(),
313	>	MEDIUM_DELAY_MS, MILLISECONDS);
314	>	shouldThrow();
315	>	} catch (RejectedExecutionException success) {
316	>	} catch (SecurityException ok) {
317	>	}
318	>	joinPool(se);
319		}
320
321		/**
#	Line 378 | Line 392 | public class ScheduledExecutorSubclassTe
392		threadProceed.await();
393		threadDone.countDown();
394		}});
395	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
395	>	await(threadStarted);
396		assertEquals(0, p.getCompletedTaskCount());
397		threadProceed.countDown();
398		threadDone.await();
399	<	Thread.sleep(SHORT_DELAY_MS);
400	<	assertEquals(1, p.getCompletedTaskCount());
399	>	long startTime = System.nanoTime();
400	>	while (p.getCompletedTaskCount() != 1) {
401	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
402	>	fail("timed out");
403	>	Thread.yield();
404	>	}
405		} finally {
406		joinPool(p);
407		}
#	Line 510 | Line 528 | public class ScheduledExecutorSubclassTe
528		}
529
530		/**
531	<	* isShutDown is false before shutdown, true after
531	>	* isShutdown is false before shutdown, true after
532		*/
533		public void testIsShutdown() {
534		CustomExecutor p = new CustomExecutor(1);
#	Line 523 | Line 541 | public class ScheduledExecutorSubclassTe
541		assertTrue(p.isShutdown());
542		}
543
526	–
544		/**
545		* isTerminated is false before termination, true after
546		*/
#	Line 642 | Line 659 | public class ScheduledExecutorSubclassTe
659		public void testPurge() throws InterruptedException {
660		CustomExecutor p = new CustomExecutor(1);
661		ScheduledFuture[] tasks = new ScheduledFuture[5];
662	<	for (int i = 0; i < tasks.length; i++) {
663	<	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
664	<	}
662	>	for (int i = 0; i < tasks.length; i++)
663	>	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
664	>	LONG_DELAY_MS, MILLISECONDS);
665		try {
666		int max = tasks.length;
667		if (tasks[4].cancel(true)) --max;
668		if (tasks[3].cancel(true)) --max;
669		// There must eventually be an interference-free point at
670		// which purge will not fail. (At worst, when queue is empty.)
671	<	int k;
672	<	for (k = 0; k < SMALL_DELAY_MS; ++k) {
671	>	long startTime = System.nanoTime();
672	>	do {
673		p.purge();
674		long count = p.getTaskCount();
675	<	if (count >= 0 && count <= max)
676	<	break;
677	<	Thread.sleep(1);
678	<	}
662	<	assertTrue(k < SMALL_DELAY_MS);
675	>	if (count == max)
676	>	return;
677	>	} while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
678	>	fail("Purge failed to remove cancelled tasks");
679		} finally {
680		for (ScheduledFuture task : tasks)
681		task.cancel(true);
#	Line 668 | Line 684 | public class ScheduledExecutorSubclassTe
684		}
685
686		/**
687	<	* shutDownNow returns a list containing tasks that were not run
687	>	* shutdownNow returns a list containing tasks that were not run
688		*/
689	<	public void testShutDownNow() {
689	>	public void testShutdownNow() {
690		CustomExecutor p = new CustomExecutor(1);
691		for (int i = 0; i < 5; i++)
692	<	p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
693	<	List l;
692	>	p.schedule(new SmallPossiblyInterruptedRunnable(),
693	>	LONG_DELAY_MS, MILLISECONDS);
694		try {
695	<	l = p.shutdownNow();
695	>	List<Runnable> l = p.shutdownNow();
696	>	assertTrue(p.isShutdown());
697	>	assertEquals(5, l.size());
698		} catch (SecurityException ok) {
699	<	return;
699	>	// Allowed in case test doesn't have privs
700	>	} finally {
701	>	joinPool(p);
702		}
683	–	assertTrue(p.isShutdown());
684	–	assertTrue(l.size() > 0 && l.size() <= 5);
685	–	joinPool(p);
703		}
704
705		/**
706		* In default setting, shutdown cancels periodic but not delayed
707		* tasks at shutdown
708		*/
709	<	public void testShutDown1() throws InterruptedException {
709	>	public void testShutdown1() throws InterruptedException {
710		CustomExecutor p = new CustomExecutor(1);
711		assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
712		assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
#	Line 714 | Line 731 | public class ScheduledExecutorSubclassTe
731		}
732		}
733
717	–
734		/**
735		* If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
736		* delayed tasks are cancelled at shutdown
737		*/
738	<	public void testShutDown2() throws InterruptedException {
738	>	public void testShutdown2() throws InterruptedException {
739		CustomExecutor p = new CustomExecutor(1);
740		p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
741		assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
#	Line 741 | Line 757 | public class ScheduledExecutorSubclassTe
757		}
758		}
759
744	–
760		/**
761		* If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
762		* periodic tasks are cancelled at shutdown
763		*/
764	<	public void testShutDown3() throws InterruptedException {
764	>	public void testShutdown3() throws InterruptedException {
765		CustomExecutor p = new CustomExecutor(1);
766		assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
767		assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
768		p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
769		assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
770		assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
771	+	long initialDelay = LONG_DELAY_MS;
772		ScheduledFuture task =
773	<	p.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS);
773	>	p.scheduleAtFixedRate(new NoOpRunnable(), initialDelay,
774	>	5, MILLISECONDS);
775		try { p.shutdown(); } catch (SecurityException ok) { return; }
776		assertTrue(p.isShutdown());
760	–	BlockingQueue q = p.getQueue();
777		assertTrue(p.getQueue().isEmpty());
778		assertTrue(task.isDone());
779		assertTrue(task.isCancelled());
780	<	assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
765	<	assertTrue(p.isTerminated());
780	>	joinPool(p);
781		}
782
783		/**
784		* if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
785		* periodic tasks are not cancelled at shutdown
786		*/
787	<	public void testShutDown4() throws InterruptedException {
787	>	public void testShutdown4() throws InterruptedException {
788		CustomExecutor p = new CustomExecutor(1);
789		final CountDownLatch counter = new CountDownLatch(2);
790		try {
#	Line 1211 | Line 1226 | public class ScheduledExecutorSubclassTe
1226		l.add(new StringTask());
1227		List<Future<String>> futures =
1228		e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1229	<	assertEquals(3, futures.size());
1230	<	Iterator<Future<String>> it = futures.iterator();
1231	<	Future<String> f1 = it.next();
1232	<	Future<String> f2 = it.next();
1233	<	Future<String> f3 = it.next();
1219	<	assertTrue(f1.isDone());
1220	<	assertTrue(f2.isDone());
1221	<	assertTrue(f3.isDone());
1222	<	assertFalse(f1.isCancelled());
1223	<	assertTrue(f2.isCancelled());
1229	>	assertEquals(l.size(), futures.size());
1230	>	for (Future future : futures)
1231	>	assertTrue(future.isDone());
1232	>	assertFalse(futures.get(0).isCancelled());
1233	>	assertTrue(futures.get(1).isCancelled());
1234		} finally {
1235		joinPool(e);
1236		}

Diff Legend

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