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.18 by dl, Tue Aug 4 13:58:09 2009 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 11 | Line 12 | import java.util.*;
12		import java.util.concurrent.*;
13		import java.math.BigInteger;
14		import java.security.*;
15	+	import sun.security.util.SecurityConstants;
16
17		public class ExecutorsTest extends JSR166TestCase{
18		public static void main(String[] args) {
#	Line 68 | Line 70 | public class ExecutorsTest extends JSR16
70		e.execute(new NoOpRunnable());
71		e.execute(new NoOpRunnable());
72		e.execute(new NoOpRunnable());
73	<	e.shutdown();
73	>	joinPool(e);
74		}
75
76		/**
#	Line 79 | Line 81 | public class ExecutorsTest extends JSR16
81		e.execute(new NoOpRunnable());
82		e.execute(new NoOpRunnable());
83		e.execute(new NoOpRunnable());
84	<	e.shutdown();
84	>	joinPool(e);
85		}
86
87		/**
#	Line 103 | Line 105 | public class ExecutorsTest extends JSR16
105		e.execute(new NoOpRunnable());
106		e.execute(new NoOpRunnable());
107		e.execute(new NoOpRunnable());
108	<	e.shutdown();
108	>	joinPool(e);
109		}
110
111		/**
#	Line 114 | Line 116 | public class ExecutorsTest extends JSR16
116		e.execute(new NoOpRunnable());
117		e.execute(new NoOpRunnable());
118		e.execute(new NoOpRunnable());
119	<	e.shutdown();
119	>	joinPool(e);
120		}
121
122		/**
#	Line 130 | Line 132 | public class ExecutorsTest extends JSR16
132		}
133
134		/**
135	+	* A new SingleThreadExecutor cannot be casted to concrete implementation
136	+	*/
137	+	public void testCastNewSingleThreadExecutor() {
138	+	ExecutorService e = Executors.newSingleThreadExecutor();
139	+	try {
140	+	ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
141	+	} catch (ClassCastException success) {
142	+	} finally {
143	+	joinPool(e);
144	+	}
145	+	}
146	+
147	+
148	+	/**
149		* A new newFixedThreadPool can execute runnables
150		*/
151		public void testNewFixedThreadPool1() {
#	Line 137 | Line 153 | public class ExecutorsTest extends JSR16
153		e.execute(new NoOpRunnable());
154		e.execute(new NoOpRunnable());
155		e.execute(new NoOpRunnable());
156	<	e.shutdown();
156	>	joinPool(e);
157		}
158
159		/**
#	Line 148 | Line 164 | public class ExecutorsTest extends JSR16
164		e.execute(new NoOpRunnable());
165		e.execute(new NoOpRunnable());
166		e.execute(new NoOpRunnable());
167	<	e.shutdown();
167	>	joinPool(e);
168		}
169
170		/**
#	Line 177 | Line 193 | public class ExecutorsTest extends JSR16
193
194
195		/**
196	+	* An unconfigurable newFixedThreadPool can execute runnables
197	+	*/
198	+	public void testunconfigurableExecutorService() {
199	+	ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
200	+	e.execute(new NoOpRunnable());
201	+	e.execute(new NoOpRunnable());
202	+	e.execute(new NoOpRunnable());
203	+	joinPool(e);
204	+	}
205	+
206	+	/**
207	+	* unconfigurableExecutorService(null) throws NPE
208	+	*/
209	+	public void testunconfigurableExecutorServiceNPE() {
210	+	try {
211	+	ExecutorService e = Executors.unconfigurableExecutorService(null);
212	+	}
213	+	catch (NullPointerException success) {
214	+	}
215	+	}
216	+
217	+	/**
218	+	* unconfigurableScheduledExecutorService(null) throws NPE
219	+	*/
220	+	public void testunconfigurableScheduledExecutorServiceNPE() {
221	+	try {
222	+	ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
223	+	}
224	+	catch (NullPointerException success) {
225	+	}
226	+	}
227	+
228	+
229	+	/**
230	+	* a newSingleThreadScheduledExecutor successfully runs delayed task
231	+	*/
232	+	public void testNewSingleThreadScheduledExecutor() {
233	+	try {
234	+	TrackedCallable callable = new TrackedCallable();
235	+	ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
236	+	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
237	+	assertFalse(callable.done);
238	+	Thread.sleep(MEDIUM_DELAY_MS);
239	+	assertTrue(callable.done);
240	+	assertEquals(Boolean.TRUE, f.get());
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	+	joinPool(p1);
262	+	} catch(RejectedExecutionException e){}
263	+	catch(Exception e){
264	+	e.printStackTrace();
265	+	unexpectedException();
266	+	}
267	+	}
268	+
269	+	/**
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	+	joinPool(p1);
282	+	} catch(RejectedExecutionException e){}
283	+	catch(Exception e){
284	+	e.printStackTrace();
285	+	unexpectedException();
286	+	}
287	+	}
288	+
289	+	/**
290		*  timeouts from execute will time out if they compute too long.
291		*/
292		public void testTimedCallable() {
#	Line 225 | Line 335 | public class ExecutorsTest extends JSR16
335		final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
336		Runnable r = new Runnable() {
337		public void run() {
338	<	Thread current = Thread.currentThread();
339	<	threadAssertTrue(!current.isDaemon());
340	<	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
341	<	ThreadGroup g = current.getThreadGroup();
342	<	SecurityManager s = System.getSecurityManager();
343	<	if (s != null)
344	<	threadAssertTrue(g == s.getThreadGroup());
345	<	else
346	<	threadAssertTrue(g == egroup);
347	<	String name = current.getName();
348	<	threadAssertTrue(name.endsWith("thread-1"));
338	>	try {
339	>	Thread current = Thread.currentThread();
340	>	threadAssertTrue(!current.isDaemon());
341	>	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
342	>	ThreadGroup g = current.getThreadGroup();
343	>	SecurityManager s = System.getSecurityManager();
344	>	if (s != null)
345	>	threadAssertTrue(g == s.getThreadGroup());
346	>	else
347	>	threadAssertTrue(g == egroup);
348	>	String name = current.getName();
349	>	threadAssertTrue(name.endsWith("thread-1"));
350	>	} catch (SecurityException ok) {
351	>	// Also pass if not allowed to change setting
352	>	}
353		}
354		};
355		ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
356
357		e.execute(r);
358	<	e.shutdown();
358	>	try {
359	>	e.shutdown();
360	>	} catch(SecurityException ok) {
361	>	}
362	>
363		try {
364		Thread.sleep(SHORT_DELAY_MS);
365		} catch (Exception eX) {
#	Line 257 | Line 375 | public class ExecutorsTest extends JSR16
375		* access control context and context class loader
376		*/
377		public void testPrivilegedThreadFactory() {
378	<	Policy savedPolicy = Policy.getPolicy();
379	<	AdjustablePolicy policy = new AdjustablePolicy();
380	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
381	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
382	<	Policy.setPolicy(policy);
378	>	Policy savedPolicy = null;
379	>	try {
380	>	savedPolicy = Policy.getPolicy();
381	>	AdjustablePolicy policy = new AdjustablePolicy();
382	>	policy.addPermission(new RuntimePermission("getContextClassLoader"));
383	>	policy.addPermission(new RuntimePermission("setContextClassLoader"));
384	>	Policy.setPolicy(policy);
385	>	} catch (AccessControlException ok) {
386	>	return;
387	>	}
388		final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
389		final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
390		final AccessControlContext thisacc = AccessController.getContext();
391		Runnable r = new Runnable() {
392		public void run() {
393	<	Thread current = Thread.currentThread();
394	<	threadAssertTrue(!current.isDaemon());
395	<	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
396	<	ThreadGroup g = current.getThreadGroup();
397	<	SecurityManager s = System.getSecurityManager();
398	<	if (s != null)
399	<	threadAssertTrue(g == s.getThreadGroup());
400	<	else
401	<	threadAssertTrue(g == egroup);
402	<	String name = current.getName();
403	<	threadAssertTrue(name.endsWith("thread-1"));
404	<	threadAssertTrue(thisccl == current.getContextClassLoader());
405	<	threadAssertTrue(thisacc.equals(AccessController.getContext()));
393	>	try {
394	>	Thread current = Thread.currentThread();
395	>	threadAssertTrue(!current.isDaemon());
396	>	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
397	>	ThreadGroup g = current.getThreadGroup();
398	>	SecurityManager s = System.getSecurityManager();
399	>	if (s != null)
400	>	threadAssertTrue(g == s.getThreadGroup());
401	>	else
402	>	threadAssertTrue(g == egroup);
403	>	String name = current.getName();
404	>	threadAssertTrue(name.endsWith("thread-1"));
405	>	threadAssertTrue(thisccl == current.getContextClassLoader());
406	>	threadAssertTrue(thisacc.equals(AccessController.getContext()));
407	>	} catch(SecurityException ok) {
408	>	// Also pass if not allowed to change settings
409	>	}
410		}
411		};
412		ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
413
414		Policy.setPolicy(savedPolicy);
415		e.execute(r);
416	<	e.shutdown();
416	>	try {
417	>	e.shutdown();
418	>	} catch(SecurityException ok) {
419	>	}
420		try {
421		Thread.sleep(SHORT_DELAY_MS);
422		} catch (Exception ex) {
#	Line 297 | Line 427 | public class ExecutorsTest extends JSR16
427
428		}
429
430	+	void checkCCL() {
431	+	SecurityManager sm = System.getSecurityManager();
432	+	if (sm != null) {
433	+	sm.checkPermission(new RuntimePermission("setContextClassLoader"));
434	+	sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
435	+	}
436	+	}
437	+
438	+	class CheckCCL implements Callable<Object> {
439	+	public Object call() {
440	+	checkCCL();
441	+	return null;
442	+	}
443	+	}
444	+
445	+
446	+	/**
447	+	* Without class loader permissions, creating
448	+	* privilegedCallableUsingCurrentClassLoader throws ACE
449	+	*/
450	+	public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
451	+	Policy savedPolicy = null;
452	+	try {
453	+	savedPolicy = Policy.getPolicy();
454	+	AdjustablePolicy policy = new AdjustablePolicy();
455	+	Policy.setPolicy(policy);
456	+	} catch (AccessControlException ok) {
457	+	return;
458	+	}
459	+
460	+	// Check if program still has too many permissions to run test
461	+	try {
462	+	checkCCL();
463	+	// too many privileges to test; so return
464	+	Policy.setPolicy(savedPolicy);
465	+	return;
466	+	} catch(AccessControlException ok) {
467	+	}
468	+
469	+	try {
470	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
471	+	shouldThrow();
472	+	} catch(AccessControlException success) {
473	+	} catch(Exception ex) {
474	+	unexpectedException();
475	+	}
476	+	finally {
477	+	Policy.setPolicy(savedPolicy);
478	+	}
479	+	}
480	+
481	+	/**
482	+	* With class loader permissions, calling
483	+	* privilegedCallableUsingCurrentClassLoader does not throw ACE
484	+	*/
485	+	public void testprivilegedCallableUsingCCLWithPrivs() {
486	+	Policy savedPolicy = null;
487	+	try {
488	+	savedPolicy = Policy.getPolicy();
489	+	AdjustablePolicy policy = new AdjustablePolicy();
490	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
491	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
492	+	Policy.setPolicy(policy);
493	+	} catch (AccessControlException ok) {
494	+	return;
495	+	}
496	+
497	+	try {
498	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
499	+	task.call();
500	+	} catch(Exception ex) {
501	+	unexpectedException();
502	+	}
503	+	finally {
504	+	Policy.setPolicy(savedPolicy);
505	+	}
506	+	}
507	+
508	+	/**
509	+	* Without permissions, calling privilegedCallable throws ACE
510	+	*/
511	+	public void testprivilegedCallableWithNoPrivs() {
512	+	Callable task;
513	+	Policy savedPolicy = null;
514	+	AdjustablePolicy policy = null;
515	+	AccessControlContext noprivAcc = null;
516	+	try {
517	+	savedPolicy = Policy.getPolicy();
518	+	policy = new AdjustablePolicy();
519	+	Policy.setPolicy(policy);
520	+	noprivAcc = AccessController.getContext();
521	+	task = Executors.privilegedCallable(new CheckCCL());
522	+	Policy.setPolicy(savedPolicy);
523	+	} catch (AccessControlException ok) {
524	+	return; // program has too few permissions to set up test
525	+	}
526	+
527	+	// Make sure that program doesn't have too many permissions
528	+	try {
529	+	AccessController.doPrivileged(new PrivilegedAction() {
530	+	public Object run() {
531	+	checkCCL();
532	+	return null;
533	+	}}, noprivAcc);
534	+	// too many permssions; skip test
535	+	return;
536	+	} catch(AccessControlException ok) {
537	+	}
538	+
539	+	try {
540	+	task.call();
541	+	shouldThrow();
542	+	} catch(AccessControlException success) {
543	+	} catch(Exception ex) {
544	+	unexpectedException();
545	+	}
546	+	}
547	+
548	+	/**
549	+	* With permissions, calling privilegedCallable succeeds
550	+	*/
551	+	public void testprivilegedCallableWithPrivs() {
552	+	Policy savedPolicy = null;
553	+	try {
554	+	savedPolicy = Policy.getPolicy();
555	+	AdjustablePolicy policy = new AdjustablePolicy();
556	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
557	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
558	+	Policy.setPolicy(policy);
559	+	} catch (AccessControlException ok) {
560	+	return;
561	+	}
562	+
563	+	Callable task = Executors.privilegedCallable(new CheckCCL());
564	+	try {
565	+	task.call();
566	+	} catch(Exception ex) {
567	+	unexpectedException();
568	+	} finally {
569	+	Policy.setPolicy(savedPolicy);
570	+	}
571	+	}
572	+
573	+	/**
574	+	* callable(Runnable) returns null when called
575	+	*/
576	+	public void testCallable1() {
577	+	try {
578	+	Callable c = Executors.callable(new NoOpRunnable());
579	+	assertNull(c.call());
580	+	} catch(Exception ex) {
581	+	unexpectedException();
582	+	}
583	+
584	+	}
585	+
586	+	/**
587	+	* callable(Runnable, result) returns result when called
588	+	*/
589	+	public void testCallable2() {
590	+	try {
591	+	Callable c = Executors.callable(new NoOpRunnable(), one);
592	+	assertEquals(one, c.call());
593	+	} catch(Exception ex) {
594	+	unexpectedException();
595	+	}
596	+	}
597	+
598	+	/**
599	+	* callable(PrivilegedAction) returns its result when called
600	+	*/
601	+	public void testCallable3() {
602	+	try {
603	+	Callable c = Executors.callable(new PrivilegedAction() {
604	+	public Object run() { return one; }});
605	+	assertEquals(one, c.call());
606	+	} catch(Exception ex) {
607	+	unexpectedException();
608	+	}
609	+	}
610	+
611	+	/**
612	+	* callable(PrivilegedExceptionAction) returns its result when called
613	+	*/
614	+	public void testCallable4() {
615	+	try {
616	+	Callable c = Executors.callable(new PrivilegedExceptionAction() {
617	+	public Object run() { return one; }});
618	+	assertEquals(one, c.call());
619	+	} catch(Exception ex) {
620	+	unexpectedException();
621	+	}
622	+	}
623	+
624	+
625	+	/**
626	+	* callable(null Runnable) throws NPE
627	+	*/
628	+	public void testCallableNPE1() {
629	+	try {
630	+	Runnable r = null;
631	+	Callable c = Executors.callable(r);
632	+	} catch (NullPointerException success) {
633	+	}
634	+	}
635	+
636	+	/**
637	+	* callable(null, result) throws NPE
638	+	*/
639	+	public void testCallableNPE2() {
640	+	try {
641	+	Runnable r = null;
642	+	Callable c = Executors.callable(r, one);
643	+	} catch (NullPointerException success) {
644	+	}
645	+	}
646	+
647	+	/**
648	+	* callable(null PrivilegedAction) throws NPE
649	+	*/
650	+	public void testCallableNPE3() {
651	+	try {
652	+	PrivilegedAction r = null;
653	+	Callable c = Executors.callable(r);
654	+	} catch (NullPointerException success) {
655	+	}
656	+	}
657	+
658	+	/**
659	+	* callable(null PrivilegedExceptionAction) throws NPE
660	+	*/
661	+	public void testCallableNPE4() {
662	+	try {
663	+	PrivilegedExceptionAction r = null;
664	+	Callable c = Executors.callable(r);
665	+	} catch (NullPointerException success) {
666	+	}
667	+	}
668	+
669	+
670		}

Diff Legend

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