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.20 by jsr166, Thu Apr 14 22:55:08 2011 UTC vs.
Revision 1.28 by jsr166, Tue May 31 16:16:24 2011 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 48 | Line 48 | public class ScheduledExecutorSubclassTe
48		}
49		}
50
51	–
51		public class CustomExecutor extends ScheduledThreadPoolExecutor {
52
53		protected <V> RunnableScheduledFuture<V> decorateTask(Runnable r, RunnableScheduledFuture<V> task) {
#	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 203 | Line 196 | public class ScheduledExecutorSubclassTe
196		RunnableCounter counter = new RunnableCounter();
197		ScheduledFuture h =
198		p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
199	<	Thread.sleep(SMALL_DELAY_MS);
199	>	delay(SMALL_DELAY_MS);
200		h.cancel(true);
201		int c = counter.count.get();
202		// By time scaling conventions, we must have at least
#	Line 221 | Line 214 | public class ScheduledExecutorSubclassTe
214		RunnableCounter counter = new RunnableCounter();
215		ScheduledFuture h =
216		p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
217	<	Thread.sleep(SMALL_DELAY_MS);
217	>	delay(SMALL_DELAY_MS);
218		h.cancel(true);
219		int c = counter.count.get();
220		assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
#	Line 229 | Line 222 | public class ScheduledExecutorSubclassTe
222		joinPool(p);
223		}
224
232	–
225		/**
226		* execute(null) throws NPE
227		*/
#	Line 378 | Line 370 | public class ScheduledExecutorSubclassTe
370		threadProceed.await();
371		threadDone.countDown();
372		}});
373	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
373	>	await(threadStarted);
374		assertEquals(0, p.getCompletedTaskCount());
375		threadProceed.countDown();
376		threadDone.await();
377	<	Thread.sleep(SHORT_DELAY_MS);
378	<	assertEquals(1, p.getCompletedTaskCount());
377	>	long startTime = System.nanoTime();
378	>	while (p.getCompletedTaskCount() != 1) {
379	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
380	>	fail("timed out");
381	>	Thread.yield();
382	>	}
383		} finally {
384		joinPool(p);
385		}
#	Line 510 | Line 506 | public class ScheduledExecutorSubclassTe
506		}
507
508		/**
509	<	* isShutDown is false before shutdown, true after
509	>	* isShutdown is false before shutdown, true after
510		*/
511		public void testIsShutdown() {
512		CustomExecutor p = new CustomExecutor(1);
#	Line 523 | Line 519 | public class ScheduledExecutorSubclassTe
519		assertTrue(p.isShutdown());
520		}
521
526	–
522		/**
523		* isTerminated is false before termination, true after
524		*/
#	Line 642 | Line 637 | public class ScheduledExecutorSubclassTe
637		public void testPurge() throws InterruptedException {
638		CustomExecutor p = new CustomExecutor(1);
639		ScheduledFuture[] tasks = new ScheduledFuture[5];
640	<	for (int i = 0; i < tasks.length; i++) {
641	<	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
642	<	}
640	>	for (int i = 0; i < tasks.length; i++)
641	>	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
642	>	LONG_DELAY_MS, MILLISECONDS);
643		try {
644		int max = tasks.length;
645		if (tasks[4].cancel(true)) --max;
646		if (tasks[3].cancel(true)) --max;
647		// There must eventually be an interference-free point at
648		// which purge will not fail. (At worst, when queue is empty.)
649	<	int k;
650	<	for (k = 0; k < SMALL_DELAY_MS; ++k) {
649	>	long startTime = System.nanoTime();
650	>	do {
651		p.purge();
652		long count = p.getTaskCount();
653	<	if (count >= 0 && count <= max)
654	<	break;
655	<	Thread.sleep(1);
656	<	}
662	<	assertTrue(k < SMALL_DELAY_MS);
653	>	if (count == max)
654	>	return;
655	>	} while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
656	>	fail("Purge failed to remove cancelled tasks");
657		} finally {
658		for (ScheduledFuture task : tasks)
659		task.cancel(true);
#	Line 668 | Line 662 | public class ScheduledExecutorSubclassTe
662		}
663
664		/**
665	<	* shutDownNow returns a list containing tasks that were not run
665	>	* shutdownNow returns a list containing tasks that were not run
666		*/
667	<	public void testShutDownNow() {
667	>	public void testShutdownNow() {
668		CustomExecutor p = new CustomExecutor(1);
669		for (int i = 0; i < 5; i++)
670	<	p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
671	<	List l;
670	>	p.schedule(new SmallPossiblyInterruptedRunnable(),
671	>	LONG_DELAY_MS, MILLISECONDS);
672		try {
673	<	l = p.shutdownNow();
673	>	List<Runnable> l = p.shutdownNow();
674	>	assertTrue(p.isShutdown());
675	>	assertEquals(5, l.size());
676		} catch (SecurityException ok) {
677	<	return;
677	>	// Allowed in case test doesn't have privs
678	>	} finally {
679	>	joinPool(p);
680		}
683	–	assertTrue(p.isShutdown());
684	–	assertTrue(l.size() > 0 && l.size() <= 5);
685	–	joinPool(p);
681		}
682
683		/**
684		* In default setting, shutdown cancels periodic but not delayed
685		* tasks at shutdown
686		*/
687	<	public void testShutDown1() throws InterruptedException {
687	>	public void testShutdown1() throws InterruptedException {
688		CustomExecutor p = new CustomExecutor(1);
689		assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
690		assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
#	Line 714 | Line 709 | public class ScheduledExecutorSubclassTe
709		}
710		}
711
717	–
712		/**
713		* If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
714		* delayed tasks are cancelled at shutdown
715		*/
716	<	public void testShutDown2() throws InterruptedException {
716	>	public void testShutdown2() throws InterruptedException {
717		CustomExecutor p = new CustomExecutor(1);
718		p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
719		assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
#	Line 741 | Line 735 | public class ScheduledExecutorSubclassTe
735		}
736		}
737
744	–
738		/**
739		* If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
740		* periodic tasks are cancelled at shutdown
741		*/
742	<	public void testShutDown3() throws InterruptedException {
742	>	public void testShutdown3() throws InterruptedException {
743		CustomExecutor p = new CustomExecutor(1);
744		assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
745		assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
746		p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
747		assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
748		assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
749	+	long initialDelay = LONG_DELAY_MS;
750		ScheduledFuture task =
751	<	p.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS);
751	>	p.scheduleAtFixedRate(new NoOpRunnable(), initialDelay,
752	>	5, MILLISECONDS);
753		try { p.shutdown(); } catch (SecurityException ok) { return; }
754		assertTrue(p.isShutdown());
760	–	BlockingQueue q = p.getQueue();
755		assertTrue(p.getQueue().isEmpty());
756		assertTrue(task.isDone());
757		assertTrue(task.isCancelled());
758	<	assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
765	<	assertTrue(p.isTerminated());
758	>	joinPool(p);
759		}
760
761		/**
762		* if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
763		* periodic tasks are not cancelled at shutdown
764		*/
765	<	public void testShutDown4() throws InterruptedException {
765	>	public void testShutdown4() throws InterruptedException {
766		CustomExecutor p = new CustomExecutor(1);
767		final CountDownLatch counter = new CountDownLatch(2);
768		try {
#	Line 1211 | Line 1204 | public class ScheduledExecutorSubclassTe
1204		l.add(new StringTask());
1205		List<Future<String>> futures =
1206		e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1207	<	assertEquals(3, futures.size());
1208	<	Iterator<Future<String>> it = futures.iterator();
1209	<	Future<String> f1 = it.next();
1210	<	Future<String> f2 = it.next();
1211	<	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());
1207	>	assertEquals(l.size(), futures.size());
1208	>	for (Future future : futures)
1209	>	assertTrue(future.isDone());
1210	>	assertFalse(futures.get(0).isCancelled());
1211	>	assertTrue(futures.get(1).isCancelled());
1212		} finally {
1213		joinPool(e);
1214		}

Diff Legend

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