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.10 by tim, Wed Dec 10 01:51:12 2003 UTC vs.
Revision 1.13 by dl, Mon Jan 19 15:49:02 2004 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
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
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9
#	Line 130 | Line 131 | public class ExecutorsTest extends JSR16
131		}
132
133		/**
134	+	* A new SingleThreadExecutor cannot be casted to concrete implementation
135	+	*/
136	+	public void testCastNewSingleThreadExecutor() {
137	+	ExecutorService e = Executors.newSingleThreadExecutor();
138	+	try {
139	+	ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
140	+	} catch (ClassCastException success) {
141	+	} finally {
142	+	joinPool(e);
143	+	}
144	+	}
145	+
146	+
147	+	/**
148		* A new newFixedThreadPool can execute runnables
149		*/
150		public void testNewFixedThreadPool1() {
#	Line 177 | Line 192 | public class ExecutorsTest extends JSR16
192
193
194		/**
195	+	* An unconfigurable newFixedThreadPool can execute runnables
196	+	*/
197	+	public void testunconfigurableExecutorService() {
198	+	ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
199	+	e.execute(new NoOpRunnable());
200	+	e.execute(new NoOpRunnable());
201	+	e.execute(new NoOpRunnable());
202	+	e.shutdown();
203	+	}
204	+
205	+	/**
206	+	* unconfigurableExecutorService(null) throws NPE
207	+	*/
208	+	public void testunconfigurableExecutorServiceNPE() {
209	+	try {
210	+	ExecutorService e = Executors.unconfigurableExecutorService(null);
211	+	}
212	+	catch (NullPointerException success) {
213	+	}
214	+	}
215	+
216	+	/**
217	+	* unconfigurableScheduledExecutorService(null) throws NPE
218	+	*/
219	+	public void testunconfigurableScheduledExecutorServiceNPE() {
220	+	try {
221	+	ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
222	+	}
223	+	catch (NullPointerException success) {
224	+	}
225	+	}
226	+
227	+
228	+	/**
229	+	* a newSingleThreadScheduledExecutor successfully runs delayed task
230	+	*/
231	+	public void testNewSingleThreadScheduledExecutor() {
232	+	try {
233	+	TrackedCallable callable = new TrackedCallable();
234	+	ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
235	+	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
236	+	assertFalse(callable.done);
237	+	Thread.sleep(MEDIUM_DELAY_MS);
238	+	assertTrue(callable.done);
239	+	assertEquals(Boolean.TRUE, f.get());
240	+	p1.shutdown();
241	+	joinPool(p1);
242	+	} catch(RejectedExecutionException e){}
243	+	catch(Exception e){
244	+	e.printStackTrace();
245	+	unexpectedException();
246	+	}
247	+	}
248	+
249	+	/**
250	+	* a newScheduledThreadPool successfully runs delayed task
251	+	*/
252	+	public void testnewScheduledThreadPool() {
253	+	try {
254	+	TrackedCallable callable = new TrackedCallable();
255	+	ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
256	+	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
257	+	assertFalse(callable.done);
258	+	Thread.sleep(MEDIUM_DELAY_MS);
259	+	assertTrue(callable.done);
260	+	assertEquals(Boolean.TRUE, f.get());
261	+	p1.shutdown();
262	+	joinPool(p1);
263	+	} catch(RejectedExecutionException e){}
264	+	catch(Exception e){
265	+	e.printStackTrace();
266	+	unexpectedException();
267	+	}
268	+	}
269	+
270	+	/**
271	+	* an unconfigurable  newScheduledThreadPool successfully runs delayed task
272	+	*/
273	+	public void testunconfigurableScheduledExecutorService() {
274	+	try {
275	+	TrackedCallable callable = new TrackedCallable();
276	+	ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
277	+	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
278	+	assertFalse(callable.done);
279	+	Thread.sleep(MEDIUM_DELAY_MS);
280	+	assertTrue(callable.done);
281	+	assertEquals(Boolean.TRUE, f.get());
282	+	p1.shutdown();
283	+	joinPool(p1);
284	+	} catch(RejectedExecutionException e){}
285	+	catch(Exception e){
286	+	e.printStackTrace();
287	+	unexpectedException();
288	+	}
289	+	}
290	+
291	+	/**
292		*  timeouts from execute will time out if they compute too long.
293		*/
294		public void testTimedCallable() {
#	Line 225 | Line 337 | public class ExecutorsTest extends JSR16
337		final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
338		Runnable r = new Runnable() {
339		public void run() {
340	<	Thread current = Thread.currentThread();
341	<	threadAssertTrue(!current.isDaemon());
342	<	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
343	<	ThreadGroup g = current.getThreadGroup();
344	<	SecurityManager s = System.getSecurityManager();
345	<	if (s != null)
346	<	threadAssertTrue(g == s.getThreadGroup());
347	<	else
348	<	threadAssertTrue(g == egroup);
349	<	String name = current.getName();
350	<	threadAssertTrue(name.endsWith("thread-1"));
340	>	try {
341	>	Thread current = Thread.currentThread();
342	>	threadAssertTrue(!current.isDaemon());
343	>	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
344	>	ThreadGroup g = current.getThreadGroup();
345	>	SecurityManager s = System.getSecurityManager();
346	>	if (s != null)
347	>	threadAssertTrue(g == s.getThreadGroup());
348	>	else
349	>	threadAssertTrue(g == egroup);
350	>	String name = current.getName();
351	>	threadAssertTrue(name.endsWith("thread-1"));
352	>	} catch (SecurityException ok) {
353	>	// Also pass if not allowed to change setting
354	>	}
355		}
356		};
357		ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
#	Line 267 | Line 383 | public class ExecutorsTest extends JSR16
383		final AccessControlContext thisacc = AccessController.getContext();
384		Runnable r = new Runnable() {
385		public void run() {
386	<	Thread current = Thread.currentThread();
387	<	threadAssertTrue(!current.isDaemon());
388	<	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
389	<	ThreadGroup g = current.getThreadGroup();
390	<	SecurityManager s = System.getSecurityManager();
391	<	if (s != null)
392	<	threadAssertTrue(g == s.getThreadGroup());
393	<	else
394	<	threadAssertTrue(g == egroup);
395	<	String name = current.getName();
396	<	threadAssertTrue(name.endsWith("thread-1"));
397	<	threadAssertTrue(thisccl == current.getContextClassLoader());
398	<	threadAssertTrue(thisacc.equals(AccessController.getContext()));
399	<	}
386	>	try {
387	>	Thread current = Thread.currentThread();
388	>	threadAssertTrue(!current.isDaemon());
389	>	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
390	>	ThreadGroup g = current.getThreadGroup();
391	>	SecurityManager s = System.getSecurityManager();
392	>	if (s != null)
393	>	threadAssertTrue(g == s.getThreadGroup());
394	>	else
395	>	threadAssertTrue(g == egroup);
396	>	String name = current.getName();
397	>	threadAssertTrue(name.endsWith("thread-1"));
398	>	threadAssertTrue(thisccl == current.getContextClassLoader());
399	>	threadAssertTrue(thisacc.equals(AccessController.getContext()));
400	>	} catch(SecurityException ok) {
401	>	// Also pass if not allowed to change settings
402	>	}
403		};
404		ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
405
#	Line 297 | Line 416 | public class ExecutorsTest extends JSR16
416
417		}
418
419	+	static class CheckCCL implements Callable<Object> {
420	+	public Object call() {
421	+	AccessControlContext acc = AccessController.getContext();
422	+	acc.checkPermission(new RuntimePermission("getContextClassLoader"));
423	+	return null;
424	+	}
425	+	}
426	+
427	+
428	+	/**
429	+	* Without class loader permissions, creating
430	+	* privilegedCallableUsingCurrentClassLoader throws ACE
431	+	*/
432	+	public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
433	+	Policy savedPolicy = Policy.getPolicy();
434	+	AdjustablePolicy policy = new AdjustablePolicy();
435	+	Policy.setPolicy(policy);
436	+	try {
437	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
438	+	shouldThrow();
439	+	} catch(AccessControlException success) {
440	+	} catch(Exception ex) {
441	+	unexpectedException();
442	+	}
443	+	finally {
444	+	Policy.setPolicy(savedPolicy);
445	+	}
446	+	}
447	+
448	+	/**
449	+	* Without class loader permissions, calling
450	+	* privilegedCallableUsingCurrentClassLoader throws ACE
451	+	*/
452	+	public void testprivilegedCallableUsingCCLWithPrivs() {
453	+	Policy savedPolicy = Policy.getPolicy();
454	+	AdjustablePolicy policy = new AdjustablePolicy();
455	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
456	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
457	+	Policy.setPolicy(policy);
458	+	try {
459	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
460	+	task.call();
461	+	} catch(Exception ex) {
462	+	unexpectedException();
463	+	}
464	+	finally {
465	+	Policy.setPolicy(savedPolicy);
466	+	}
467	+	}
468	+
469	+	/**
470	+	* Without permissions, calling privilegedCallable throws ACE
471	+	*/
472	+	public void testprivilegedCallableWithNoPrivs() {
473	+	Policy savedPolicy = Policy.getPolicy();
474	+	AdjustablePolicy policy = new AdjustablePolicy();
475	+	Policy.setPolicy(policy);
476	+	Callable task = Executors.privilegedCallable(new CheckCCL());
477	+	Policy.setPolicy(savedPolicy);
478	+	try {
479	+	task.call();
480	+	shouldThrow();
481	+	} catch(AccessControlException success) {
482	+	} catch(Exception ex) {
483	+	unexpectedException();
484	+	} finally {
485	+	}
486	+	}
487	+
488	+	/**
489	+	* With permissions, calling privilegedCallable succeeds
490	+	*/
491	+	public void testprivilegedCallableWithPrivs() {
492	+	Policy savedPolicy = Policy.getPolicy();
493	+	AdjustablePolicy policy = new AdjustablePolicy();
494	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
495	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
496	+	Policy.setPolicy(policy);
497	+	Callable task = Executors.privilegedCallable(new CheckCCL());
498	+	try {
499	+	task.call();
500	+	} catch(Exception ex) {
501	+	unexpectedException();
502	+	} finally {
503	+	Policy.setPolicy(savedPolicy);
504	+	}
505	+	}
506	+
507	+	/**
508	+	* callable(Runnable) returns null when called
509	+	*/
510	+	public void testCallable1() {
511	+	try {
512	+	Callable c = Executors.callable(new NoOpRunnable());
513	+	assertNull(c.call());
514	+	} catch(Exception ex) {
515	+	unexpectedException();
516	+	}
517	+
518	+	}
519	+
520	+	/**
521	+	* callable(Runnable, result) returns result when called
522	+	*/
523	+	public void testCallable2() {
524	+	try {
525	+	Callable c = Executors.callable(new NoOpRunnable(), one);
526	+	assertEquals(one, c.call());
527	+	} catch(Exception ex) {
528	+	unexpectedException();
529	+	}
530	+	}
531	+
532	+	/**
533	+	* callable(PrivilegedAction) returns its result when called
534	+	*/
535	+	public void testCallable3() {
536	+	try {
537	+	Callable c = Executors.callable(new PrivilegedAction() {
538	+	public Object run() { return one; }});
539	+	assertEquals(one, c.call());
540	+	} catch(Exception ex) {
541	+	unexpectedException();
542	+	}
543	+	}
544	+
545	+	/**
546	+	* callable(PrivilegedExceptionAction) returns its result when called
547	+	*/
548	+	public void testCallable4() {
549	+	try {
550	+	Callable c = Executors.callable(new PrivilegedExceptionAction() {
551	+	public Object run() { return one; }});
552	+	assertEquals(one, c.call());
553	+	} catch(Exception ex) {
554	+	unexpectedException();
555	+	}
556	+	}
557	+
558	+
559	+	/**
560	+	* callable(null Runnable) throws NPE
561	+	*/
562	+	public void testCallableNPE1() {
563	+	try {
564	+	Runnable r = null;
565	+	Callable c = Executors.callable(r);
566	+	} catch (NullPointerException success) {
567	+	}
568	+	}
569	+
570	+	/**
571	+	* callable(null, result) throws NPE
572	+	*/
573	+	public void testCallableNPE2() {
574	+	try {
575	+	Runnable r = null;
576	+	Callable c = Executors.callable(r, one);
577	+	} catch (NullPointerException success) {
578	+	}
579	+	}
580	+
581	+	/**
582	+	* callable(null PrivilegedAction) throws NPE
583	+	*/
584	+	public void testCallableNPE3() {
585	+	try {
586	+	PrivilegedAction r = null;
587	+	Callable c = Executors.callable(r);
588	+	} catch (NullPointerException success) {
589	+	}
590	+	}
591	+
592	+	/**
593	+	* callable(null PrivilegedExceptionAction) throws NPE
594	+	*/
595	+	public void testCallableNPE4() {
596	+	try {
597	+	PrivilegedExceptionAction r = null;
598	+	Callable c = Executors.callable(r);
599	+	} catch (NullPointerException success) {
600	+	}
601	+	}
602	+
603	+
604		}

Diff Legend

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