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.9 by tim, Tue Dec 9 19:09:24 2003 UTC vs.
Revision 1.11 by dl, Mon Dec 22 00:48:55 2003 UTC

#	Line 20 | Line 20 | public class ExecutorsTest extends JSR16
20		return new TestSuite(ExecutorsTest.class);
21		}
22
23	–	private static final String TEST_STRING = "a test string";
24	–
25	–	private static class StringTask implements Callable<String> {
26	–	public String call() { return TEST_STRING; }
27	–	}
28	–
29	–	static class DirectExecutor implements Executor {
30	–	public void execute(Runnable r) {
31	–	r.run();
32	–	}
33	–	}
34	–
23		static class TimedCallable<T> implements Callable<T> {
24	<	private final Executor exec;
24	>	private final ExecutorService exec;
25		private final Callable<T> func;
26		private final long msecs;
27
28	<	TimedCallable(Executor exec, Callable<T> func, long msecs) {
28	>	TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
29		this.exec = exec;
30		this.func = func;
31		this.msecs = msecs;
32		}
33
34		public T call() throws Exception {
35	<	Future<T> ftask = Executors.execute(exec, func);
35	>	Future<T> ftask = exec.submit(func);
36		try {
37		return ftask.get(msecs, TimeUnit.MILLISECONDS);
38		} finally {
#	Line 142 | Line 130 | public class ExecutorsTest extends JSR16
130		}
131
132		/**
133	+	* A new SingleThreadExecutor cannot be casted to concrete implementation
134	+	*/
135	+	public void testCastNewSingleThreadExecutor() {
136	+	ExecutorService e = Executors.newSingleThreadExecutor();
137	+	try {
138	+	ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
139	+	} catch (ClassCastException success) {
140	+	} finally {
141	+	joinPool(e);
142	+	}
143	+	}
144	+
145	+
146	+	/**
147		* A new newFixedThreadPool can execute runnables
148		*/
149		public void testNewFixedThreadPool1() {
#	Line 187 | Line 189 | public class ExecutorsTest extends JSR16
189		}
190		}
191
190	–	/**
191	–	* execute of runnable runs it to completion
192	–	*/
193	–	public void testExecuteRunnable() {
194	–	try {
195	–	Executor e = new DirectExecutor();
196	–	TrackedShortRunnable task = new TrackedShortRunnable();
197	–	assertFalse(task.done);
198	–	Future<?> future = Executors.execute(e, task);
199	–	future.get();
200	–	assertTrue(task.done);
201	–	}
202	–	catch (ExecutionException ex) {
203	–	unexpectedException();
204	–	}
205	–	catch (InterruptedException ex) {
206	–	unexpectedException();
207	–	}
208	–	}
209	–
210	–	/**
211	–	* invoke of a runnable runs it to completion
212	–	*/
213	–	public void testInvokeRunnable() {
214	–	try {
215	–	Executor e = new DirectExecutor();
216	–	TrackedShortRunnable task = new TrackedShortRunnable();
217	–	assertFalse(task.done);
218	–	Executors.invoke(e, task);
219	–	assertTrue(task.done);
220	–	}
221	–	catch (ExecutionException ex) {
222	–	unexpectedException();
223	–	}
224	–	catch (InterruptedException ex) {
225	–	unexpectedException();
226	–	}
227	–	}
228	–
229	–	/**
230	–	* execute of a callable runs it to completion
231	–	*/
232	–	public void testExecuteCallable() {
233	–	try {
234	–	Executor e = new DirectExecutor();
235	–	Future<String> future = Executors.execute(e, new StringTask());
236	–	String result = future.get();
237	–	assertSame(TEST_STRING, result);
238	–	}
239	–	catch (ExecutionException ex) {
240	–	unexpectedException();
241	–	}
242	–	catch (InterruptedException ex) {
243	–	unexpectedException();
244	–	}
245	–	}
246	–
247	–
248	–	/**
249	–	* execute of a privileged action runs it to completion
250	–	*/
251	–	public void testExecutePrivilegedAction() {
252	–	Policy savedPolicy = Policy.getPolicy();
253	–	AdjustablePolicy policy = new AdjustablePolicy();
254	–	policy.addPermission(new RuntimePermission("getContextClassLoader"));
255	–	policy.addPermission(new RuntimePermission("setContextClassLoader"));
256	–	Policy.setPolicy(policy);
257	–	try {
258	–	Executor e = new DirectExecutor();
259	–	Future future = Executors.execute(e, new PrivilegedAction() {
260	–	public Object run() {
261	–	return TEST_STRING;
262	–	}});
263	–
264	–	Object result = future.get();
265	–	assertSame(TEST_STRING, result);
266	–	}
267	–	catch (ExecutionException ex) {
268	–	unexpectedException();
269	–	}
270	–	catch (InterruptedException ex) {
271	–	unexpectedException();
272	–	}
273	–	finally {
274	–	Policy.setPolicy(savedPolicy);
275	–	}
276	–	}
277	–
278	–	/**
279	–	* execute of a privileged exception action runs it to completion
280	–	*/
281	–	public void testExecutePrivilegedExceptionAction() {
282	–	Policy savedPolicy = Policy.getPolicy();
283	–	AdjustablePolicy policy = new AdjustablePolicy();
284	–	policy.addPermission(new RuntimePermission("getContextClassLoader"));
285	–	policy.addPermission(new RuntimePermission("setContextClassLoader"));
286	–	Policy.setPolicy(policy);
287	–	try {
288	–	Executor e = new DirectExecutor();
289	–	Future future = Executors.execute(e, new PrivilegedExceptionAction() {
290	–	public Object run() {
291	–	return TEST_STRING;
292	–	}});
293	–
294	–	Object result = future.get();
295	–	assertSame(TEST_STRING, result);
296	–	}
297	–	catch (ExecutionException ex) {
298	–	unexpectedException();
299	–	}
300	–	catch (InterruptedException ex) {
301	–	unexpectedException();
302	–	}
303	–	finally {
304	–	Policy.setPolicy(savedPolicy);
305	–	}
306	–	}
307	–
308	–	/**
309	–	* execute of a failed privileged exception action reports exception
310	–	*/
311	–	public void testExecuteFailedPrivilegedExceptionAction() {
312	–	Policy savedPolicy = Policy.getPolicy();
313	–	AdjustablePolicy policy = new AdjustablePolicy();
314	–	policy.addPermission(new RuntimePermission("getContextClassLoader"));
315	–	policy.addPermission(new RuntimePermission("setContextClassLoader"));
316	–	Policy.setPolicy(policy);
317	–	try {
318	–	Executor e = new DirectExecutor();
319	–	Future future = Executors.execute(e, new PrivilegedExceptionAction() {
320	–	public Object run() throws Exception {
321	–	throw new IndexOutOfBoundsException();
322	–	}});
323	–
324	–	Object result = future.get();
325	–	shouldThrow();
326	–	}
327	–	catch (ExecutionException success) {
328	–	}
329	–	catch (InterruptedException ex) {
330	–	unexpectedException();
331	–	}
332	–	finally {
333	–	Policy.setPolicy(savedPolicy);
334	–	}
335	–	}
192
193		/**
194	<	* invoke of a collable runs it to completion
194	>	* An unconfigurable newFixedThreadPool can execute runnables
195		*/
196	<	public void testInvokeCallable() {
197	<	try {
198	<	Executor e = new DirectExecutor();
199	<	String result = Executors.invoke(e, new StringTask());
200	<
201	<	assertSame(TEST_STRING, result);
346	<	}
347	<	catch (ExecutionException ex) {
348	<	unexpectedException();
349	<	}
350	<	catch (InterruptedException ex) {
351	<	unexpectedException();
352	<	}
196	>	public void testunconfigurableExecutorService() {
197	>	ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
198	>	e.execute(new NoOpRunnable());
199	>	e.execute(new NoOpRunnable());
200	>	e.execute(new NoOpRunnable());
201	>	e.shutdown();
202		}
203
204		/**
205	<	* execute with null executor throws NPE
205	>	* unconfigurableExecutorService(null) throws NPE
206		*/
207	<	public void testNullExecuteRunnable() {
207	>	public void testunconfigurableExecutorServiceNPE() {
208		try {
209	<	TrackedShortRunnable task = new TrackedShortRunnable();
361	<	assertFalse(task.done);
362	<	Future<?> future = Executors.execute(null, task);
363	<	shouldThrow();
209	>	ExecutorService e = Executors.unconfigurableExecutorService(null);
210		}
211		catch (NullPointerException success) {
212		}
367	–	catch (Exception ex) {
368	–	unexpectedException();
369	–	}
213		}
214
215		/**
216	<	* execute with a null runnable throws NPE
216	>	* unconfigurableScheduledExecutorService(null) throws NPE
217		*/
218	<	public void testExecuteNullRunnable() {
218	>	public void testunconfigurableScheduledExecutorServiceNPE() {
219		try {
220	<	Executor e = new DirectExecutor();
378	<	TrackedShortRunnable task = null;
379	<	Future<?> future = Executors.execute(e, task);
380	<	shouldThrow();
220	>	ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
221		}
222		catch (NullPointerException success) {
223		}
384	–	catch (Exception ex) {
385	–	unexpectedException();
386	–	}
224		}
225
389	–	/**
390	–	* invoke of a null runnable throws NPE
391	–	*/
392	–	public void testInvokeNullRunnable() {
393	–	try {
394	–	Executor e = new DirectExecutor();
395	–	TrackedShortRunnable task = null;
396	–	Executors.invoke(e, task);
397	–	shouldThrow();
398	–	}
399	–	catch (NullPointerException success) {
400	–	}
401	–	catch (Exception ex) {
402	–	unexpectedException();
403	–	}
404	–	}
226
227		/**
228	<	* execute of a null callable throws NPE
228	>	* a newSingleThreadScheduledExecutor successfully runs delayed task
229		*/
230	<	public void testExecuteNullCallable() {
231	<	try {
232	<	Executor e = new DirectExecutor();
233	<	StringTask t = null;
234	<	Future<String> future = Executors.execute(e, t);
235	<	shouldThrow();
236	<	}
237	<	catch (NullPointerException success) {
238	<	}
239	<	catch (Exception ex) {
230	>	public void testNewSingleThreadScheduledExecutor() {
231	>	try {
232	>	TrackedCallable callable = new TrackedCallable();
233	>	ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
234	>	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
235	>	assertFalse(callable.done);
236	>	Thread.sleep(MEDIUM_DELAY_MS);
237	>	assertTrue(callable.done);
238	>	assertEquals(Boolean.TRUE, f.get());
239	>	p1.shutdown();
240	>	joinPool(p1);
241	>	} catch(RejectedExecutionException e){}
242	>	catch(Exception e){
243	>	e.printStackTrace();
244		unexpectedException();
245		}
246		}
247
248		/**
249	<	* invoke of a null callable throws NPE
250	<	*/
251	<	public void testInvokeNullCallable() {
252	<	try {
253	<	Executor e = new DirectExecutor();
254	<	StringTask t = null;
255	<	String result = Executors.invoke(e, t);
256	<	shouldThrow();
257	<	}
258	<	catch (NullPointerException success) {
259	<	}
260	<	catch (Exception ex) {
249	>	* a newScheduledThreadPool successfully runs delayed task
250	>	*/
251	>	public void testnewScheduledThreadPool() {
252	>	try {
253	>	TrackedCallable callable = new TrackedCallable();
254	>	ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
255	>	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
256	>	assertFalse(callable.done);
257	>	Thread.sleep(MEDIUM_DELAY_MS);
258	>	assertTrue(callable.done);
259	>	assertEquals(Boolean.TRUE, f.get());
260	>	p1.shutdown();
261	>	joinPool(p1);
262	>	} catch(RejectedExecutionException e){}
263	>	catch(Exception e){
264	>	e.printStackTrace();
265		unexpectedException();
266		}
267		}
268
269		/**
270	<	*  execute(Executor, Runnable) throws RejectedExecutionException
271	<	*  if saturated.
272	<	*/
273	<	public void testExecute1() {
274	<	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
275	<	try {
276	<
277	<	for(int i = 0; i < 5; ++i){
278	<	Executors.execute(p, new MediumRunnable());
279	<	}
280	<	shouldThrow();
281	<	} catch(RejectedExecutionException success){}
282	<	joinPool(p);
283	<	}
284	<
285	<	/**
457	<	*  execute(Executor, Callable)throws RejectedExecutionException
458	<	*  if saturated.
459	<	*/
460	<	public void testExecute2() {
461	<	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
462	<	try {
463	<	for(int i = 0; i < 5; ++i) {
464	<	Executors.execute(p, new SmallCallable());
465	<	}
466	<	shouldThrow();
467	<	} catch(RejectedExecutionException e){}
468	<	joinPool(p);
469	<	}
470	<
471	<
472	<	/**
473	<	*  invoke(Executor, Runnable) throws InterruptedException if
474	<	*  caller interrupted.
475	<	*/
476	<	public void testInterruptedInvoke() {
477	<	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
478	<	Thread t = new Thread(new Runnable() {
479	<	public void run() {
480	<	try {
481	<	Executors.invoke(p,new Runnable() {
482	<	public void run() {
483	<	try {
484	<	Thread.sleep(MEDIUM_DELAY_MS);
485	<	shouldThrow();
486	<	} catch(InterruptedException e){
487	<	}
488	<	}
489	<	});
490	<	} catch(InterruptedException success){
491	<	} catch(Exception e) {
492	<	unexpectedException();
493	<	}
494	<
495	<	}
496	<	});
497	<	try {
498	<	t.start();
499	<	Thread.sleep(SHORT_DELAY_MS);
500	<	t.interrupt();
501	<	} catch(Exception e){
270	>	* an unconfigurable  newScheduledThreadPool successfully runs delayed task
271	>	*/
272	>	public void testunconfigurableScheduledExecutorService() {
273	>	try {
274	>	TrackedCallable callable = new TrackedCallable();
275	>	ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
276	>	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
277	>	assertFalse(callable.done);
278	>	Thread.sleep(MEDIUM_DELAY_MS);
279	>	assertTrue(callable.done);
280	>	assertEquals(Boolean.TRUE, f.get());
281	>	p1.shutdown();
282	>	joinPool(p1);
283	>	} catch(RejectedExecutionException e){}
284	>	catch(Exception e){
285	>	e.printStackTrace();
286		unexpectedException();
287		}
504	–	joinPool(p);
288		}
289
290		/**
508	–	*  invoke(Executor, Runnable) throws ExecutionException if
509	–	*  runnable throws exception.
510	–	*/
511	–	public void testInvoke3() {
512	–	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
513	–	try {
514	–	Runnable r = new Runnable() {
515	–	public void run() {
516	–	int i = 5/0;
517	–	}
518	–	};
519	–
520	–	for(int i =0; i < 5; i++){
521	–	Executors.invoke(p,r);
522	–	}
523	–
524	–	shouldThrow();
525	–	} catch(ExecutionException success){
526	–	} catch(Exception e){
527	–	unexpectedException();
528	–	}
529	–	joinPool(p);
530	–	}
531	–
532	–
533	–
534	–	/**
535	–	*  invoke(Executor, Callable) throws InterruptedException if
536	–	*  callable throws exception
537	–	*/
538	–	public void testInvoke5() {
539	–	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
540	–
541	–	final Callable c = new Callable() {
542	–	public Object call() {
543	–	try {
544	–	Executors.invoke(p, new SmallCallable());
545	–	shouldThrow();
546	–	} catch(InterruptedException e){}
547	–	catch(RejectedExecutionException e2){}
548	–	catch(ExecutionException e3){}
549	–	return Boolean.TRUE;
550	–	}
551	–	};
552	–
553	–
554	–
555	–	Thread t = new Thread(new Runnable() {
556	–	public void run() {
557	–	try {
558	–	c.call();
559	–	} catch(Exception e){}
560	–	}
561	–	});
562	–	try {
563	–	t.start();
564	–	Thread.sleep(SHORT_DELAY_MS);
565	–	t.interrupt();
566	–	t.join();
567	–	} catch(InterruptedException e){
568	–	unexpectedException();
569	–	}
570	–
571	–	joinPool(p);
572	–	}
573	–
574	–	/**
575	–	*  invoke(Executor, Callable) will throw ExecutionException
576	–	*  if callable throws exception
577	–	*/
578	–	public void testInvoke6() {
579	–	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
580	–
581	–	try {
582	–	Callable c = new Callable() {
583	–	public Object call() {
584	–	int i = 5/0;
585	–	return Boolean.TRUE;
586	–	}
587	–	};
588	–
589	–	for(int i =0; i < 5; i++){
590	–	Executors.invoke(p,c);
591	–	}
592	–
593	–	shouldThrow();
594	–	}
595	–	catch(ExecutionException success){
596	–	} catch(Exception e) {
597	–	unexpectedException();
598	–	}
599	–	joinPool(p);
600	–	}
601	–
602	–
603	–
604	–	/**
291		*  timeouts from execute will time out if they compute too long.
292		*/
293		public void testTimedCallable() {
#	Line 722 | Line 408 | public class ExecutorsTest extends JSR16
408
409		}
410
411	+	static class CheckCCL implements Callable<Object> {
412	+	public Object call() {
413	+	AccessControlContext acc = AccessController.getContext();
414	+	acc.checkPermission(new RuntimePermission("getContextClassLoader"));
415	+	return null;
416	+	}
417	+	}
418	+
419	+
420	+	/**
421	+	* Without class loader permissions, creating
422	+	* privilegedCallableUsingCurrentClassLoader throws ACE
423	+	*/
424	+	public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
425	+	Policy savedPolicy = Policy.getPolicy();
426	+	AdjustablePolicy policy = new AdjustablePolicy();
427	+	Policy.setPolicy(policy);
428	+	try {
429	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
430	+	shouldThrow();
431	+	} catch(AccessControlException success) {
432	+	} catch(Exception ex) {
433	+	unexpectedException();
434	+	}
435	+	finally {
436	+	Policy.setPolicy(savedPolicy);
437	+	}
438	+	}
439	+
440	+	/**
441	+	* Without class loader permissions, calling
442	+	* privilegedCallableUsingCurrentClassLoader throws ACE
443	+	*/
444	+	public void testprivilegedCallableUsingCCLWithPrivs() {
445	+	Policy savedPolicy = Policy.getPolicy();
446	+	AdjustablePolicy policy = new AdjustablePolicy();
447	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
448	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
449	+	Policy.setPolicy(policy);
450	+	try {
451	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
452	+	task.call();
453	+	} catch(Exception ex) {
454	+	unexpectedException();
455	+	}
456	+	finally {
457	+	Policy.setPolicy(savedPolicy);
458	+	}
459	+	}
460	+
461	+	/**
462	+	* Without permissions, calling privilegedCallable throws ACE
463	+	*/
464	+	public void testprivilegedCallableWithNoPrivs() {
465	+	Policy savedPolicy = Policy.getPolicy();
466	+	AdjustablePolicy policy = new AdjustablePolicy();
467	+	Policy.setPolicy(policy);
468	+	Callable task = Executors.privilegedCallable(new CheckCCL());
469	+	Policy.setPolicy(savedPolicy);
470	+	try {
471	+	task.call();
472	+	shouldThrow();
473	+	} catch(AccessControlException success) {
474	+	} catch(Exception ex) {
475	+	unexpectedException();
476	+	} finally {
477	+	}
478	+	}
479	+
480	+	/**
481	+	* With permissions, calling privilegedCallable succeeds
482	+	*/
483	+	public void testprivilegedCallableWithPrivs() {
484	+	Policy savedPolicy = Policy.getPolicy();
485	+	AdjustablePolicy policy = new AdjustablePolicy();
486	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
487	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
488	+	Policy.setPolicy(policy);
489	+	Callable task = Executors.privilegedCallable(new CheckCCL());
490	+	try {
491	+	task.call();
492	+	} catch(Exception ex) {
493	+	unexpectedException();
494	+	} finally {
495	+	Policy.setPolicy(savedPolicy);
496	+	}
497	+	}
498	+
499	+	/**
500	+	* callable(Runnable) returns null when called
501	+	*/
502	+	public void testCallable1() {
503	+	try {
504	+	Callable c = Executors.callable(new NoOpRunnable());
505	+	assertNull(c.call());
506	+	} catch(Exception ex) {
507	+	unexpectedException();
508	+	}
509	+
510	+	}
511	+
512	+	/**
513	+	* callable(Runnable, result) returns result when called
514	+	*/
515	+	public void testCallable2() {
516	+	try {
517	+	Callable c = Executors.callable(new NoOpRunnable(), one);
518	+	assertEquals(one, c.call());
519	+	} catch(Exception ex) {
520	+	unexpectedException();
521	+	}
522	+	}
523	+
524	+	/**
525	+	* callable(PrivilegedAction) returns its result when called
526	+	*/
527	+	public void testCallable3() {
528	+	try {
529	+	Callable c = Executors.callable(new PrivilegedAction() {
530	+	public Object run() { return one; }});
531	+	assertEquals(one, c.call());
532	+	} catch(Exception ex) {
533	+	unexpectedException();
534	+	}
535	+	}
536	+
537	+	/**
538	+	* callable(PrivilegedExceptionAction) returns its result when called
539	+	*/
540	+	public void testCallable4() {
541	+	try {
542	+	Callable c = Executors.callable(new PrivilegedExceptionAction() {
543	+	public Object run() { return one; }});
544	+	assertEquals(one, c.call());
545	+	} catch(Exception ex) {
546	+	unexpectedException();
547	+	}
548	+	}
549	+
550	+
551	+	/**
552	+	* callable(null Runnable) throws NPE
553	+	*/
554	+	public void testCallableNPE1() {
555	+	try {
556	+	Runnable r = null;
557	+	Callable c = Executors.callable(r);
558	+	} catch (NullPointerException success) {
559	+	}
560	+	}
561	+
562	+	/**
563	+	* callable(null, result) throws NPE
564	+	*/
565	+	public void testCallableNPE2() {
566	+	try {
567	+	Runnable r = null;
568	+	Callable c = Executors.callable(r, one);
569	+	} catch (NullPointerException success) {
570	+	}
571	+	}
572	+
573	+	/**
574	+	* callable(null PrivilegedAction) throws NPE
575	+	*/
576	+	public void testCallableNPE3() {
577	+	try {
578	+	PrivilegedAction r = null;
579	+	Callable c = Executors.callable(r);
580	+	} catch (NullPointerException success) {
581	+	}
582	+	}
583	+
584	+	/**
585	+	* callable(null PrivilegedExceptionAction) throws NPE
586	+	*/
587	+	public void testCallableNPE4() {
588	+	try {
589	+	PrivilegedExceptionAction r = null;
590	+	Callable c = Executors.callable(r);
591	+	} catch (NullPointerException success) {
592	+	}
593	+	}
594	+
595	+
596		}

Diff Legend

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