ViewVC Help

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

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

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents):
Revision 1.34 by jsr166, Sat Oct 9 19:30:35 2010 UTC vs.
Revision 1.44 by jsr166, Sun Feb 22 19:16:12 2015 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
8
9	–
10	–	import junit.framework.*;
11	–	import java.util.*;
12	–	import java.util.concurrent.*;
9		import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	<	import java.math.BigInteger;
11	<	import java.security.*;
10	>
11	>	import java.security.AccessControlContext;
12	>	import java.security.AccessControlException;
13	>	import java.security.AccessController;
14	>	import java.security.PrivilegedAction;
15	>	import java.security.PrivilegedExceptionAction;
16	>	import java.util.ArrayList;
17	>	import java.util.List;
18	>	import java.util.concurrent.Callable;
19	>	import java.util.concurrent.CountDownLatch;
20	>	import java.util.concurrent.Executors;
21	>	import java.util.concurrent.ExecutorService;
22	>	import java.util.concurrent.Future;
23	>	import java.util.concurrent.ScheduledExecutorService;
24	>	import java.util.concurrent.ThreadPoolExecutor;
25	>
26	>	import junit.framework.Test;
27	>	import junit.framework.TestSuite;
28
29		public class ExecutorsTest extends JSR166TestCase {
30		public static void main(String[] args) {
#	Line 54 | Line 66 | public class ExecutorsTest extends JSR16
66		} catch (NullPointerException success) {}
67		}
68
57	–
69		/**
70		* A new SingleThreadExecutor can execute runnables
71		*/
#	Line 101 | Line 112 | public class ExecutorsTest extends JSR16
112		}
113		}
114
104	–
115		/**
116		* A new newFixedThreadPool can execute runnables
117		*/
#	Line 144 | Line 154 | public class ExecutorsTest extends JSR16
154		} catch (IllegalArgumentException success) {}
155		}
156
147	–
157		/**
158		* An unconfigurable newFixedThreadPool can execute runnables
159		*/
160	<	public void testunconfigurableExecutorService() {
160	>	public void testUnconfigurableExecutorService() {
161		ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
162		e.execute(new NoOpRunnable());
163		e.execute(new NoOpRunnable());
#	Line 159 | Line 168 | public class ExecutorsTest extends JSR16
168		/**
169		* unconfigurableExecutorService(null) throws NPE
170		*/
171	<	public void testunconfigurableExecutorServiceNPE() {
171	>	public void testUnconfigurableExecutorServiceNPE() {
172		try {
173		ExecutorService e = Executors.unconfigurableExecutorService(null);
174		shouldThrow();
#	Line 169 | Line 178 | public class ExecutorsTest extends JSR16
178		/**
179		* unconfigurableScheduledExecutorService(null) throws NPE
180		*/
181	<	public void testunconfigurableScheduledExecutorServiceNPE() {
181	>	public void testUnconfigurableScheduledExecutorServiceNPE() {
182		try {
183		ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
184		shouldThrow();
185		} catch (NullPointerException success) {}
186		}
187
179	–
188		/**
189		* a newSingleThreadScheduledExecutor successfully runs delayed task
190		*/
191		public void testNewSingleThreadScheduledExecutor() throws Exception {
192	<	TrackedCallable callable = new TrackedCallable();
193	<	ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
194	<	Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
195	<	assertFalse(callable.done);
196	<	Thread.sleep(MEDIUM_DELAY_MS);
197	<	assertTrue(callable.done);
198	<	assertEquals(Boolean.TRUE, f.get());
199	<	joinPool(p1);
192	>	ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
193	>	try {
194	>	final CountDownLatch proceed = new CountDownLatch(1);
195	>	final Runnable task = new CheckedRunnable() {
196	>	public void realRun() {
197	>	await(proceed);
198	>	}};
199	>	long startTime = System.nanoTime();
200	>	Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
201	>	timeoutMillis(), MILLISECONDS);
202	>	assertFalse(f.isDone());
203	>	proceed.countDown();
204	>	assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
205	>	assertSame(Boolean.TRUE, f.get());
206	>	assertTrue(f.isDone());
207	>	assertFalse(f.isCancelled());
208	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
209	>	} finally {
210	>	joinPool(p);
211	>	}
212		}
213
214		/**
215		* a newScheduledThreadPool successfully runs delayed task
216		*/
217	<	public void testnewScheduledThreadPool() throws Exception {
218	<	TrackedCallable callable = new TrackedCallable();
219	<	ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
220	<	Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
221	<	assertFalse(callable.done);
222	<	Thread.sleep(MEDIUM_DELAY_MS);
223	<	assertTrue(callable.done);
224	<	assertEquals(Boolean.TRUE, f.get());
225	<	joinPool(p1);
217	>	public void testNewScheduledThreadPool() throws Exception {
218	>	ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
219	>	try {
220	>	final CountDownLatch proceed = new CountDownLatch(1);
221	>	final Runnable task = new CheckedRunnable() {
222	>	public void realRun() {
223	>	await(proceed);
224	>	}};
225	>	long startTime = System.nanoTime();
226	>	Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
227	>	timeoutMillis(), MILLISECONDS);
228	>	assertFalse(f.isDone());
229	>	proceed.countDown();
230	>	assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
231	>	assertSame(Boolean.TRUE, f.get());
232	>	assertTrue(f.isDone());
233	>	assertFalse(f.isCancelled());
234	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
235	>	} finally {
236	>	joinPool(p);
237	>	}
238		}
239
240		/**
241		* an unconfigurable newScheduledThreadPool successfully runs delayed task
242		*/
243	<	public void testunconfigurableScheduledExecutorService() throws Exception {
244	<	TrackedCallable callable = new TrackedCallable();
245	<	ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
246	<	Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
247	<	assertFalse(callable.done);
248	<	Thread.sleep(MEDIUM_DELAY_MS);
249	<	assertTrue(callable.done);
250	<	assertEquals(Boolean.TRUE, f.get());
251	<	joinPool(p1);
243	>	public void testUnconfigurableScheduledExecutorService() throws Exception {
244	>	ScheduledExecutorService p =
245	>	Executors.unconfigurableScheduledExecutorService
246	>	(Executors.newScheduledThreadPool(2));
247	>	try {
248	>	final CountDownLatch proceed = new CountDownLatch(1);
249	>	final Runnable task = new CheckedRunnable() {
250	>	public void realRun() {
251	>	await(proceed);
252	>	}};
253	>	long startTime = System.nanoTime();
254	>	Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
255	>	timeoutMillis(), MILLISECONDS);
256	>	assertFalse(f.isDone());
257	>	proceed.countDown();
258	>	assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
259	>	assertSame(Boolean.TRUE, f.get());
260	>	assertTrue(f.isDone());
261	>	assertFalse(f.isCancelled());
262	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
263	>	} finally {
264	>	joinPool(p);
265	>	}
266		}
267
268		/**
269		* Future.get on submitted tasks will time out if they compute too long.
270		*/
271		public void testTimedCallable() throws Exception {
272	+	final ExecutorService[] executors = {
273	+	Executors.newSingleThreadExecutor(),
274	+	Executors.newCachedThreadPool(),
275	+	Executors.newFixedThreadPool(2),
276	+	Executors.newScheduledThreadPool(2),
277	+	};
278	+
279		final Runnable sleeper = new CheckedInterruptedRunnable() {
280		public void realRun() throws InterruptedException {
281	<	Thread.sleep(LONG_DELAY_MS);
281	>	delay(LONG_DELAY_MS);
282		}};
283	<	for (ExecutorService executor :
284	<	new ExecutorService[] {
285	<	Executors.newSingleThreadExecutor(),
286	<	Executors.newCachedThreadPool(),
287	<	Executors.newFixedThreadPool(2),
288	<	Executors.newScheduledThreadPool(2),
289	<	}) {
290	<	try {
238	<	Future future = executor.submit(sleeper);
239	<	try {
240	<	future.get(SHORT_DELAY_MS, MILLISECONDS);
241	<	shouldThrow();
242	<	} catch (TimeoutException success) {
243	<	} finally {
244	<	future.cancel(true);
245	<	}
246	<	}
247	<	finally {
248	<	joinPool(executor);
249	<	}
283	>
284	>	List<Thread> threads = new ArrayList<Thread>();
285	>	for (final ExecutorService executor : executors) {
286	>	threads.add(newStartedThread(new CheckedRunnable() {
287	>	public void realRun() {
288	>	Future future = executor.submit(sleeper);
289	>	assertFutureTimesOut(future);
290	>	}}));
291		}
292	+	for (Thread thread : threads)
293	+	awaitTermination(thread);
294	+	for (ExecutorService executor : executors)
295	+	joinPool(executor);
296		}
297
253	–
298		/**
299		* ThreadPoolExecutor using defaultThreadFactory has
300		* specified group, priority, daemon status, and name
301		*/
302		public void testDefaultThreadFactory() throws Exception {
303		final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
304	+	final CountDownLatch done = new CountDownLatch(1);
305		Runnable r = new CheckedRunnable() {
306		public void realRun() {
307		try {
#	Line 274 | Line 319 | public class ExecutorsTest extends JSR16
319		} catch (SecurityException ok) {
320		// Also pass if not allowed to change setting
321		}
322	+	done.countDown();
323		}};
324		ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
325
326		e.execute(r);
327	+	await(done);
328	+
329		try {
330		e.shutdown();
331		} catch (SecurityException ok) {
332		}
333
334	<	try {
287	<	Thread.sleep(SHORT_DELAY_MS);
288	<	} finally {
289	<	joinPool(e);
290	<	}
334	>	joinPool(e);
335		}
336
337		/**
#	Line 296 | Line 340 | public class ExecutorsTest extends JSR16
340		* access control context and context class loader
341		*/
342		public void testPrivilegedThreadFactory() throws Exception {
343	+	final CountDownLatch done = new CountDownLatch(1);
344		Runnable r = new CheckedRunnable() {
345		public void realRun() throws Exception {
346		final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
#	Line 316 | Line 361 | public class ExecutorsTest extends JSR16
361		assertTrue(name.endsWith("thread-1"));
362		assertSame(thisccl, current.getContextClassLoader());
363		assertEquals(thisacc, AccessController.getContext());
364	+	done.countDown();
365		}};
366		ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
367		e.execute(r);
368	+	await(done);
369		e.shutdown();
323	–	Thread.sleep(SHORT_DELAY_MS);
370		joinPool(e);
371		}};
372
#	Line 358 | Line 404 | public class ExecutorsTest extends JSR16
404		}
405		}
406
361	–
407		/**
408		* Without class loader permissions, creating
409		* privilegedCallableUsingCurrentClassLoader throws ACE
#	Line 381 | Line 426 | public class ExecutorsTest extends JSR16
426		* With class loader permissions, calling
427		* privilegedCallableUsingCurrentClassLoader does not throw ACE
428		*/
429	<	public void testprivilegedCallableUsingCCLWithPrivs() throws Exception {
429	>	public void testPrivilegedCallableUsingCCLWithPrivs() throws Exception {
430		Runnable r = new CheckedRunnable() {
431		public void realRun() throws Exception {
432		Executors.privilegedCallableUsingCurrentClassLoader
#	Line 397 | Line 442 | public class ExecutorsTest extends JSR16
442		/**
443		* Without permissions, calling privilegedCallable throws ACE
444		*/
445	<	public void testprivilegedCallableWithNoPrivs() throws Exception {
445	>	public void testPrivilegedCallableWithNoPrivs() throws Exception {
446		// Avoid classloader-related SecurityExceptions in swingui.TestRunner
447		Executors.privilegedCallable(new CheckCCL());
448
#	Line 469 | Line 514 | public class ExecutorsTest extends JSR16
514		/**
515		* With permissions, calling privilegedCallable succeeds
516		*/
517	<	public void testprivilegedCallableWithPrivs() throws Exception {
517	>	public void testPrivilegedCallableWithPrivs() throws Exception {
518		Runnable r = new CheckedRunnable() {
519		public void realRun() throws Exception {
520		Executors.privilegedCallable(new CheckCCL()).call();
521		}};
522
523	<	runWithPermissions(r,
523	>	runWithPermissions(r,
524		new RuntimePermission("getClassLoader"),
525		new RuntimePermission("setContextClassLoader"));
526		}
#	Line 514 | Line 559 | public class ExecutorsTest extends JSR16
559		assertSame(one, c.call());
560		}
561
517	–
562		/**
563		* callable(null Runnable) throws NPE
564		*/
#	Line 555 | Line 599 | public class ExecutorsTest extends JSR16
599		} catch (NullPointerException success) {}
600		}
601
558	–
602		}

Diff Legend

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