[ViewVC] Diff of: jsr166/jsr166/src/test/tck/ExecutorsTest.java

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents):
Revision 1.21 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.42 by jsr166, Sun May 29 13:45:35 2011 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	–
9		import junit.framework.*;
10		import java.util.*;
11		import java.util.concurrent.*;
12	<	import java.math.BigInteger;
12	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13		import java.security.*;
14
15	<	public class ExecutorsTest extends JSR166TestCase{
15	>	public class ExecutorsTest extends JSR166TestCase {
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run(suite());
18		}
19		public static Test suite() {
20		return new TestSuite(ExecutorsTest.class);
21		}
22
24	–	static class TimedCallable<T> implements Callable<T> {
25	–	private final ExecutorService exec;
26	–	private final Callable<T> func;
27	–	private final long msecs;
28	–
29	–	TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
30	–	this.exec = exec;
31	–	this.func = func;
32	–	this.msecs = msecs;
33	–	}
34	–
35	–	public T call() throws Exception {
36	–	Future<T> ftask = exec.submit(func);
37	–	try {
38	–	return ftask.get(msecs, TimeUnit.MILLISECONDS);
39	–	} finally {
40	–	ftask.cancel(true);
41	–	}
42	–	}
43	–	}
44	–
45	–
46	–	private static class Fib implements Callable<BigInteger> {
47	–	private final BigInteger n;
48	–	Fib(long n) {
49	–	if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
50	–	this.n = BigInteger.valueOf(n);
51	–	}
52	–	public BigInteger call() {
53	–	BigInteger f1 = BigInteger.ONE;
54	–	BigInteger f2 = f1;
55	–	for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
56	–	BigInteger t = f1.add(f2);
57	–	f1 = f2;
58	–	f2 = t;
59	–	}
60	–	return f1;
61	–	}
62	–	};
63	–
23		/**
24		* A newCachedThreadPool can execute runnables
25		*/
#	Line 90 \| Line 49 \| public class ExecutorsTest extends JSR16
49		try {
50		ExecutorService e = Executors.newCachedThreadPool(null);
51		shouldThrow();
52	<	}
94	<	catch (NullPointerException success) {
95	<	}
52	>	} catch (NullPointerException success) {}
53		}
54
98	–
55		/**
56		* A new SingleThreadExecutor can execute runnables
57		*/
#	Line 125 \| Line 81 \| public class ExecutorsTest extends JSR16
81		try {
82		ExecutorService e = Executors.newSingleThreadExecutor(null);
83		shouldThrow();
84	<	}
129	<	catch (NullPointerException success) {
130	<	}
84	>	} catch (NullPointerException success) {}
85		}
86
87		/**
#	Line 137 \| Line 91 \| public class ExecutorsTest extends JSR16
91		ExecutorService e = Executors.newSingleThreadExecutor();
92		try {
93		ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
94	+	shouldThrow();
95		} catch (ClassCastException success) {
96		} finally {
97		joinPool(e);
98		}
99		}
100
146	–
101		/**
102		* A new newFixedThreadPool can execute runnables
103		*/
#	Line 173 \| Line 127 \| public class ExecutorsTest extends JSR16
127		try {
128		ExecutorService e = Executors.newFixedThreadPool(2, null);
129		shouldThrow();
130	<	}
177	<	catch (NullPointerException success) {
178	<	}
130	>	} catch (NullPointerException success) {}
131		}
132
133		/**
#	Line 185 \| Line 137 \| public class ExecutorsTest extends JSR16
137		try {
138		ExecutorService e = Executors.newFixedThreadPool(0);
139		shouldThrow();
140	<	}
189	<	catch (IllegalArgumentException success) {
190	<	}
140	>	} catch (IllegalArgumentException success) {}
141		}
142
193	–
143		/**
144		* An unconfigurable newFixedThreadPool can execute runnables
145		*/
146	<	public void testunconfigurableExecutorService() {
146	>	public void testUnconfigurableExecutorService() {
147		ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
148		e.execute(new NoOpRunnable());
149		e.execute(new NoOpRunnable());
#	Line 205 \| Line 154 \| public class ExecutorsTest extends JSR16
154		/**
155		* unconfigurableExecutorService(null) throws NPE
156		*/
157	<	public void testunconfigurableExecutorServiceNPE() {
157	>	public void testUnconfigurableExecutorServiceNPE() {
158		try {
159		ExecutorService e = Executors.unconfigurableExecutorService(null);
160	<	}
161	<	catch (NullPointerException success) {
213	<	}
160	>	shouldThrow();
161	>	} catch (NullPointerException success) {}
162		}
163
164		/**
165		* unconfigurableScheduledExecutorService(null) throws NPE
166		*/
167	<	public void testunconfigurableScheduledExecutorServiceNPE() {
167	>	public void testUnconfigurableScheduledExecutorServiceNPE() {
168		try {
169		ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
170	<	}
171	<	catch (NullPointerException success) {
224	<	}
170	>	shouldThrow();
171	>	} catch (NullPointerException success) {}
172		}
173
227	–
174		/**
175		* a newSingleThreadScheduledExecutor successfully runs delayed task
176		*/
177	<	public void testNewSingleThreadScheduledExecutor() {
178	<	try {
179	<	TrackedCallable callable = new TrackedCallable();
180	<	ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
181	<	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
182	<	assertFalse(callable.done);
183	<	Thread.sleep(MEDIUM_DELAY_MS);
184	<	assertTrue(callable.done);
185	<	assertEquals(Boolean.TRUE, f.get());
186	<	joinPool(p1);
187	<	} catch (RejectedExecutionException e){}
188	<	catch (Exception e){
189	<	e.printStackTrace();
190	<	unexpectedException();
177	>	public void testNewSingleThreadScheduledExecutor() throws Exception {
178	>	ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
179	>	try {
180	>	final CountDownLatch proceed = new CountDownLatch(1);
181	>	final Runnable task = new CheckedRunnable() {
182	>	public void realRun() {
183	>	await(proceed);
184	>	}};
185	>	long startTime = System.nanoTime();
186	>	Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
187	>	timeoutMillis(), MILLISECONDS);
188	>	assertFalse(f.isDone());
189	>	proceed.countDown();
190	>	assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
191	>	assertSame(Boolean.TRUE, f.get());
192	>	assertTrue(f.isDone());
193	>	assertFalse(f.isCancelled());
194	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
195	>	} finally {
196	>	joinPool(p);
197		}
198		}
199
200		/**
201		* a newScheduledThreadPool successfully runs delayed task
202		*/
203	<	public void testnewScheduledThreadPool() {
204	<	try {
205	<	TrackedCallable callable = new TrackedCallable();
206	<	ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
207	<	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
208	<	assertFalse(callable.done);
209	<	Thread.sleep(MEDIUM_DELAY_MS);
210	<	assertTrue(callable.done);
211	<	assertEquals(Boolean.TRUE, f.get());
212	<	joinPool(p1);
213	<	} catch (RejectedExecutionException e){}
214	<	catch (Exception e){
215	<	e.printStackTrace();
216	<	unexpectedException();
203	>	public void testNewScheduledThreadPool() throws Exception {
204	>	ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
205	>	try {
206	>	final CountDownLatch proceed = new CountDownLatch(1);
207	>	final Runnable task = new CheckedRunnable() {
208	>	public void realRun() {
209	>	await(proceed);
210	>	}};
211	>	long startTime = System.nanoTime();
212	>	Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
213	>	timeoutMillis(), MILLISECONDS);
214	>	assertFalse(f.isDone());
215	>	proceed.countDown();
216	>	assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
217	>	assertSame(Boolean.TRUE, f.get());
218	>	assertTrue(f.isDone());
219	>	assertFalse(f.isCancelled());
220	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
221	>	} finally {
222	>	joinPool(p);
223		}
224		}
225
226		/**
227	<	* an unconfigurable newScheduledThreadPool successfully runs delayed task
227	>	* an unconfigurable newScheduledThreadPool successfully runs delayed task
228		*/
229	<	public void testunconfigurableScheduledExecutorService() {
230	<	try {
231	<	TrackedCallable callable = new TrackedCallable();
232	<	ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
233	<	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
234	<	assertFalse(callable.done);
235	<	Thread.sleep(MEDIUM_DELAY_MS);
236	<	assertTrue(callable.done);
237	<	assertEquals(Boolean.TRUE, f.get());
238	<	joinPool(p1);
239	<	} catch (RejectedExecutionException e){}
240	<	catch (Exception e){
241	<	e.printStackTrace();
242	<	unexpectedException();
229	>	public void testUnconfigurableScheduledExecutorService() throws Exception {
230	>	ScheduledExecutorService p =
231	>	Executors.unconfigurableScheduledExecutorService
232	>	(Executors.newScheduledThreadPool(2));
233	>	try {
234	>	final CountDownLatch proceed = new CountDownLatch(1);
235	>	final Runnable task = new CheckedRunnable() {
236	>	public void realRun() {
237	>	await(proceed);
238	>	}};
239	>	long startTime = System.nanoTime();
240	>	Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
241	>	timeoutMillis(), MILLISECONDS);
242	>	assertFalse(f.isDone());
243	>	proceed.countDown();
244	>	assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
245	>	assertSame(Boolean.TRUE, f.get());
246	>	assertTrue(f.isDone());
247	>	assertFalse(f.isCancelled());
248	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
249	>	} finally {
250	>	joinPool(p);
251		}
252		}
253
254		/**
255	<	* timeouts from execute will time out if they compute too long.
255	>	* Future.get on submitted tasks will time out if they compute too long.
256		*/
257	<	public void testTimedCallable() {
258	<	int N = 10000;
259	<	ExecutorService executor = Executors.newSingleThreadExecutor();
260	<	List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
261	<	try {
262	<	long startTime = System.currentTimeMillis();
263	<
264	<	long i = 0;
265	<	while (tasks.size() < N) {
266	<	tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
267	<	i += 10;
268	<	}
269	<
270	<	int iters = 0;
271	<	BigInteger sum = BigInteger.ZERO;
272	<	for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
273	<	try {
274	<	++iters;
275	<	sum = sum.add(it.next().call());
276	<	}
277	<	catch (TimeoutException success) {
278	<	assertTrue(iters > 0);
279	<	return;
280	<	}
281	<	catch (Exception e) {
316	<	unexpectedException();
317	<	}
318	<	}
319	<	// if by chance we didn't ever time out, total time must be small
320	<	long elapsed = System.currentTimeMillis() - startTime;
321	<	assertTrue(elapsed < N);
322	<	}
323	<	finally {
257	>	public void testTimedCallable() throws Exception {
258	>	final ExecutorService[] executors = {
259	>	Executors.newSingleThreadExecutor(),
260	>	Executors.newCachedThreadPool(),
261	>	Executors.newFixedThreadPool(2),
262	>	Executors.newScheduledThreadPool(2),
263	>	};
264	>
265	>	final Runnable sleeper = new CheckedInterruptedRunnable() {
266	>	public void realRun() throws InterruptedException {
267	>	delay(LONG_DELAY_MS);
268	>	}};
269	>
270	>	List<Thread> threads = new ArrayList<Thread>();
271	>	for (final ExecutorService executor : executors) {
272	>	threads.add(newStartedThread(new CheckedRunnable() {
273	>	public void realRun() {
274	>	long startTime = System.nanoTime();
275	>	Future future = executor.submit(sleeper);
276	>	assertFutureTimesOut(future);
277	>	}}));
278	>	}
279	>	for (Thread thread : threads)
280	>	awaitTermination(thread);
281	>	for (ExecutorService executor : executors)
282		joinPool(executor);
325	–	}
283		}
284
328	–
285		/**
286		* ThreadPoolExecutor using defaultThreadFactory has
287		* specified group, priority, daemon status, and name
288		*/
289	<	public void testDefaultThreadFactory() {
289	>	public void testDefaultThreadFactory() throws Exception {
290		final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
291	<	Runnable r = new Runnable() {
292	<	public void run() {
293	<	try {
294	<	Thread current = Thread.currentThread();
295	<	threadAssertTrue(!current.isDaemon());
296	<	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
297	<	ThreadGroup g = current.getThreadGroup();
298	<	SecurityManager s = System.getSecurityManager();
299	<	if (s != null)
300	<	threadAssertTrue(g == s.getThreadGroup());
301	<	else
302	<	threadAssertTrue(g == egroup);
303	<	String name = current.getName();
304	<	threadAssertTrue(name.endsWith("thread-1"));
305	<	} catch (SecurityException ok) {
306	<	// Also pass if not allowed to change setting
307	<	}
291	>	final CountDownLatch done = new CountDownLatch(1);
292	>	Runnable r = new CheckedRunnable() {
293	>	public void realRun() {
294	>	try {
295	>	Thread current = Thread.currentThread();
296	>	assertTrue(!current.isDaemon());
297	>	assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
298	>	ThreadGroup g = current.getThreadGroup();
299	>	SecurityManager s = System.getSecurityManager();
300	>	if (s != null)
301	>	assertTrue(g == s.getThreadGroup());
302	>	else
303	>	assertTrue(g == egroup);
304	>	String name = current.getName();
305	>	assertTrue(name.endsWith("thread-1"));
306	>	} catch (SecurityException ok) {
307	>	// Also pass if not allowed to change setting
308		}
309	<	};
309	>	done.countDown();
310	>	}};
311		ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
312
313		e.execute(r);
314	+	await(done);
315	+
316		try {
317		e.shutdown();
318		} catch (SecurityException ok) {
319		}
320
321	<	try {
363	<	Thread.sleep(SHORT_DELAY_MS);
364	<	} catch (Exception eX) {
365	<	unexpectedException();
366	<	} finally {
367	<	joinPool(e);
368	<	}
321	>	joinPool(e);
322		}
323
324		/**
#	Line 373 \| Line 326 \| public class ExecutorsTest extends JSR16
326		* specified group, priority, daemon status, name,
327		* access control context and context class loader
328		*/
329	<	public void testPrivilegedThreadFactory() {
330	<	Policy savedPolicy = null;
331	<	try {
332	<	savedPolicy = Policy.getPolicy();
333	<	AdjustablePolicy policy = new AdjustablePolicy();
334	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
335	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
336	<	Policy.setPolicy(policy);
337	<	} catch (AccessControlException ok) {
338	<	return;
339	<	}
340	<	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
341	<	final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
342	<	final AccessControlContext thisacc = AccessController.getContext();
343	<	Runnable r = new Runnable() {
344	<	public void run() {
345	<	try {
346	<	Thread current = Thread.currentThread();
347	<	threadAssertTrue(!current.isDaemon());
348	<	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
349	<	ThreadGroup g = current.getThreadGroup();
350	<	SecurityManager s = System.getSecurityManager();
351	<	if (s != null)
352	<	threadAssertTrue(g == s.getThreadGroup());
353	<	else
354	<	threadAssertTrue(g == egroup);
355	<	String name = current.getName();
356	<	threadAssertTrue(name.endsWith("thread-1"));
357	<	threadAssertTrue(thisccl == current.getContextClassLoader());
358	<	threadAssertTrue(thisacc.equals(AccessController.getContext()));
359	<	} catch (SecurityException ok) {
360	<	// Also pass if not allowed to change settings
361	<	}
362	<	}
363	<	};
364	<	ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
329	>	public void testPrivilegedThreadFactory() throws Exception {
330	>	final CountDownLatch done = new CountDownLatch(1);
331	>	Runnable r = new CheckedRunnable() {
332	>	public void realRun() throws Exception {
333	>	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
334	>	final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
335	>	final AccessControlContext thisacc = AccessController.getContext();
336	>	Runnable r = new CheckedRunnable() {
337	>	public void realRun() {
338	>	Thread current = Thread.currentThread();
339	>	assertTrue(!current.isDaemon());
340	>	assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
341	>	ThreadGroup g = current.getThreadGroup();
342	>	SecurityManager s = System.getSecurityManager();
343	>	if (s != null)
344	>	assertTrue(g == s.getThreadGroup());
345	>	else
346	>	assertTrue(g == egroup);
347	>	String name = current.getName();
348	>	assertTrue(name.endsWith("thread-1"));
349	>	assertSame(thisccl, current.getContextClassLoader());
350	>	assertEquals(thisacc, AccessController.getContext());
351	>	done.countDown();
352	>	}};
353	>	ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
354	>	e.execute(r);
355	>	await(done);
356	>	e.shutdown();
357	>	joinPool(e);
358	>	}};
359	>
360	>	runWithPermissions(r,
361	>	new RuntimePermission("getClassLoader"),
362	>	new RuntimePermission("setContextClassLoader"),
363	>	new RuntimePermission("modifyThread"));
364	>	}
365
366	<	Policy.setPolicy(savedPolicy);
367	<	e.execute(r);
368	<	try {
369	<	e.shutdown();
370	<	} catch (SecurityException ok) {
371	<	}
372	<	try {
373	<	Thread.sleep(SHORT_DELAY_MS);
374	<	} catch (Exception ex) {
422	<	unexpectedException();
423	<	} finally {
424	<	joinPool(e);
366	>	boolean haveCCLPermissions() {
367	>	SecurityManager sm = System.getSecurityManager();
368	>	if (sm != null) {
369	>	try {
370	>	sm.checkPermission(new RuntimePermission("setContextClassLoader"));
371	>	sm.checkPermission(new RuntimePermission("getClassLoader"));
372	>	} catch (AccessControlException e) {
373	>	return false;
374	>	}
375		}
376	<
376	>	return true;
377		}
378
379		void checkCCL() {
#	Line 441 \| Line 391 \| public class ExecutorsTest extends JSR16
391		}
392		}
393
444	–
394		/**
395		* Without class loader permissions, creating
396		* privilegedCallableUsingCurrentClassLoader throws ACE
397		*/
398		public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
399	<	Policy savedPolicy = null;
400	<	try {
401	<	savedPolicy = Policy.getPolicy();
402	<	AdjustablePolicy policy = new AdjustablePolicy();
403	<	Policy.setPolicy(policy);
404	<	} catch (AccessControlException ok) {
405	<	return;
406	<	}
407	<
459	<	// Check if program still has too many permissions to run test
460	<	try {
461	<	checkCCL();
462	<	// too many privileges to test; so return
463	<	Policy.setPolicy(savedPolicy);
464	<	return;
465	<	} catch (AccessControlException ok) {
466	<	}
399	>	Runnable r = new CheckedRunnable() {
400	>	public void realRun() throws Exception {
401	>	if (System.getSecurityManager() == null)
402	>	return;
403	>	try {
404	>	Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
405	>	shouldThrow();
406	>	} catch (AccessControlException success) {}
407	>	}};
408
409	<	try {
469	<	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
470	<	shouldThrow();
471	<	} catch (AccessControlException success) {
472	<	} catch (Exception ex) {
473	<	unexpectedException();
474	<	}
475	<	finally {
476	<	Policy.setPolicy(savedPolicy);
477	<	}
409	>	runWithoutPermissions(r);
410		}
411
412		/**
413		* With class loader permissions, calling
414		* privilegedCallableUsingCurrentClassLoader does not throw ACE
415		*/
416	<	public void testprivilegedCallableUsingCCLWithPrivs() {
417	<	Policy savedPolicy = null;
418	<	try {
419	<	savedPolicy = Policy.getPolicy();
420	<	AdjustablePolicy policy = new AdjustablePolicy();
421	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
422	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
423	<	Policy.setPolicy(policy);
424	<	} catch (AccessControlException ok) {
425	<	return;
426	<	}
495	<
496	<	try {
497	<	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
498	<	task.call();
499	<	} catch (Exception ex) {
500	<	unexpectedException();
501	<	}
502	<	finally {
503	<	Policy.setPolicy(savedPolicy);
504	<	}
416	>	public void testPrivilegedCallableUsingCCLWithPrivs() throws Exception {
417	>	Runnable r = new CheckedRunnable() {
418	>	public void realRun() throws Exception {
419	>	Executors.privilegedCallableUsingCurrentClassLoader
420	>	(new NoOpCallable())
421	>	.call();
422	>	}};
423	>
424	>	runWithPermissions(r,
425	>	new RuntimePermission("getClassLoader"),
426	>	new RuntimePermission("setContextClassLoader"));
427		}
428
429		/**
430		* Without permissions, calling privilegedCallable throws ACE
431		*/
432	<	public void testprivilegedCallableWithNoPrivs() {
433	<	Callable task;
434	<	Policy savedPolicy = null;
435	<	AdjustablePolicy policy = null;
436	<	AccessControlContext noprivAcc = null;
437	<	try {
438	<	savedPolicy = Policy.getPolicy();
439	<	policy = new AdjustablePolicy();
440	<	Policy.setPolicy(policy);
441	<	noprivAcc = AccessController.getContext();
442	<	task = Executors.privilegedCallable(new CheckCCL());
443	<	Policy.setPolicy(savedPolicy);
444	<	} catch (AccessControlException ok) {
445	<	return; // program has too few permissions to set up test
446	<	}
447	<
448	<	// Make sure that program doesn't have too many permissions
449	<	try {
450	<	AccessController.doPrivileged(new PrivilegedAction() {
451	<	public Object run() {
452	<	checkCCL();
453	<	return null;
454	<	}}, noprivAcc);
455	<	// too many permssions; skip test
456	<	return;
457	<	} catch (AccessControlException ok) {
458	<	}
459	<
460	<	try {
461	<	task.call();
462	<	shouldThrow();
463	<	} catch (AccessControlException success) {
464	<	} catch (Exception ex) {
465	<	unexpectedException();
466	<	}
432	>	public void testPrivilegedCallableWithNoPrivs() throws Exception {
433	>	// Avoid classloader-related SecurityExceptions in swingui.TestRunner
434	>	Executors.privilegedCallable(new CheckCCL());
435	>
436	>	Runnable r = new CheckedRunnable() {
437	>	public void realRun() throws Exception {
438	>	if (System.getSecurityManager() == null)
439	>	return;
440	>	Callable task = Executors.privilegedCallable(new CheckCCL());
441	>	try {
442	>	task.call();
443	>	shouldThrow();
444	>	} catch (AccessControlException success) {}
445	>	}};
446	>
447	>	runWithoutPermissions(r);
448	>
449	>	// It seems rather difficult to test that the
450	>	// AccessControlContext of the privilegedCallable is used
451	>	// instead of its caller. Below is a failed attempt to do
452	>	// that, which does not work because the AccessController
453	>	// cannot capture the internal state of the current Policy.
454	>	// It would be much more work to differentiate based on,
455	>	// e.g. CodeSource.
456	>
457	>	// final AccessControlContext[] noprivAcc = new AccessControlContext[1];
458	>	// final Callable[] task = new Callable[1];
459	>
460	>	// runWithPermissions
461	>	// (new CheckedRunnable() {
462	>	// public void realRun() {
463	>	// if (System.getSecurityManager() == null)
464	>	// return;
465	>	// noprivAcc[0] = AccessController.getContext();
466	>	// task[0] = Executors.privilegedCallable(new CheckCCL());
467	>	// try {
468	>	// AccessController.doPrivileged(new PrivilegedAction<Void>() {
469	>	// public Void run() {
470	>	// checkCCL();
471	>	// return null;
472	>	// }}, noprivAcc[0]);
473	>	// shouldThrow();
474	>	// } catch (AccessControlException success) {}
475	>	// }});
476	>
477	>	// runWithPermissions
478	>	// (new CheckedRunnable() {
479	>	// public void realRun() throws Exception {
480	>	// if (System.getSecurityManager() == null)
481	>	// return;
482	>	// // Verify that we have an underprivileged ACC
483	>	// try {
484	>	// AccessController.doPrivileged(new PrivilegedAction<Void>() {
485	>	// public Void run() {
486	>	// checkCCL();
487	>	// return null;
488	>	// }}, noprivAcc[0]);
489	>	// shouldThrow();
490	>	// } catch (AccessControlException success) {}
491	>
492	>	// try {
493	>	// task[0].call();
494	>	// shouldThrow();
495	>	// } catch (AccessControlException success) {}
496	>	// }},
497	>	// new RuntimePermission("getClassLoader"),
498	>	// new RuntimePermission("setContextClassLoader"));
499		}
500
501		/**
502		* With permissions, calling privilegedCallable succeeds
503		*/
504	<	public void testprivilegedCallableWithPrivs() {
505	<	Policy savedPolicy = null;
506	<	try {
507	<	savedPolicy = Policy.getPolicy();
508	<	AdjustablePolicy policy = new AdjustablePolicy();
509	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
510	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
511	<	Policy.setPolicy(policy);
512	<	} catch (AccessControlException ok) {
559	<	return;
560	<	}
561	<
562	<	Callable task = Executors.privilegedCallable(new CheckCCL());
563	<	try {
564	<	task.call();
565	<	} catch (Exception ex) {
566	<	unexpectedException();
567	<	} finally {
568	<	Policy.setPolicy(savedPolicy);
569	<	}
504	>	public void testPrivilegedCallableWithPrivs() throws Exception {
505	>	Runnable r = new CheckedRunnable() {
506	>	public void realRun() throws Exception {
507	>	Executors.privilegedCallable(new CheckCCL()).call();
508	>	}};
509	>
510	>	runWithPermissions(r,
511	>	new RuntimePermission("getClassLoader"),
512	>	new RuntimePermission("setContextClassLoader"));
513		}
514
515		/**
516		* callable(Runnable) returns null when called
517		*/
518	<	public void testCallable1() {
519	<	try {
520	<	Callable c = Executors.callable(new NoOpRunnable());
578	<	assertNull(c.call());
579	<	} catch (Exception ex) {
580	<	unexpectedException();
581	<	}
582	<
518	>	public void testCallable1() throws Exception {
519	>	Callable c = Executors.callable(new NoOpRunnable());
520	>	assertNull(c.call());
521		}
522
523		/**
524		* callable(Runnable, result) returns result when called
525		*/
526	<	public void testCallable2() {
527	<	try {
528	<	Callable c = Executors.callable(new NoOpRunnable(), one);
591	<	assertEquals(one, c.call());
592	<	} catch (Exception ex) {
593	<	unexpectedException();
594	<	}
526	>	public void testCallable2() throws Exception {
527	>	Callable c = Executors.callable(new NoOpRunnable(), one);
528	>	assertSame(one, c.call());
529		}
530
531		/**
532		* callable(PrivilegedAction) returns its result when called
533		*/
534	<	public void testCallable3() {
535	<	try {
536	<	Callable c = Executors.callable(new PrivilegedAction() {
537	<	public Object run() { return one; }});
604	<	assertEquals(one, c.call());
605	<	} catch (Exception ex) {
606	<	unexpectedException();
607	<	}
534	>	public void testCallable3() throws Exception {
535	>	Callable c = Executors.callable(new PrivilegedAction() {
536	>	public Object run() { return one; }});
537	>	assertSame(one, c.call());
538		}
539
540		/**
541		* callable(PrivilegedExceptionAction) returns its result when called
542		*/
543	<	public void testCallable4() {
544	<	try {
545	<	Callable c = Executors.callable(new PrivilegedExceptionAction() {
546	<	public Object run() { return one; }});
617	<	assertEquals(one, c.call());
618	<	} catch (Exception ex) {
619	<	unexpectedException();
620	<	}
543	>	public void testCallable4() throws Exception {
544	>	Callable c = Executors.callable(new PrivilegedExceptionAction() {
545	>	public Object run() { return one; }});
546	>	assertSame(one, c.call());
547		}
548
623	–
549		/**
550		* callable(null Runnable) throws NPE
551		*/
552		public void testCallableNPE1() {
553		try {
554	<	Runnable r = null;
555	<	Callable c = Executors.callable(r);
556	<	} catch (NullPointerException success) {
632	<	}
554	>	Callable c = Executors.callable((Runnable) null);
555	>	shouldThrow();
556	>	} catch (NullPointerException success) {}
557		}
558
559		/**
#	Line 637 \| Line 561 \| public class ExecutorsTest extends JSR16
561		*/
562		public void testCallableNPE2() {
563		try {
564	<	Runnable r = null;
565	<	Callable c = Executors.callable(r, one);
566	<	} catch (NullPointerException success) {
643	<	}
564	>	Callable c = Executors.callable((Runnable) null, one);
565	>	shouldThrow();
566	>	} catch (NullPointerException success) {}
567		}
568
569		/**
#	Line 648 \| Line 571 \| public class ExecutorsTest extends JSR16
571		*/
572		public void testCallableNPE3() {
573		try {
574	<	PrivilegedAction r = null;
575	<	Callable c = Executors.callable(r);
576	<	} catch (NullPointerException success) {
654	<	}
574	>	Callable c = Executors.callable((PrivilegedAction) null);
575	>	shouldThrow();
576	>	} catch (NullPointerException success) {}
577		}
578
579		/**
#	Line 659 \| Line 581 \| public class ExecutorsTest extends JSR16
581		*/
582		public void testCallableNPE4() {
583		try {
584	<	PrivilegedExceptionAction r = null;
585	<	Callable c = Executors.callable(r);
586	<	} catch (NullPointerException success) {
665	<	}
584	>	Callable c = Executors.callable((PrivilegedExceptionAction) null);
585	>	shouldThrow();
586	>	} catch (NullPointerException success) {}
587		}
588
668	–
589		}

Diff Legend

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

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents): Revision 1.21 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs. Revision 1.42 by jsr166, Sun May 29 13:45:35 2011 UTC

Diff Legend

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents):
Revision 1.21 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.42 by jsr166, Sun May 29 13:45:35 2011 UTC