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.12 by dl, Sat Dec 27 19:26:43 2003 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 297 | Line 409 | public class ExecutorsTest extends JSR16
409
410		}
411
412	+	static class CheckCCL implements Callable<Object> {
413	+	public Object call() {
414	+	AccessControlContext acc = AccessController.getContext();
415	+	acc.checkPermission(new RuntimePermission("getContextClassLoader"));
416	+	return null;
417	+	}
418	+	}
419	+
420	+
421	+	/**
422	+	* Without class loader permissions, creating
423	+	* privilegedCallableUsingCurrentClassLoader throws ACE
424	+	*/
425	+	public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
426	+	Policy savedPolicy = Policy.getPolicy();
427	+	AdjustablePolicy policy = new AdjustablePolicy();
428	+	Policy.setPolicy(policy);
429	+	try {
430	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
431	+	shouldThrow();
432	+	} catch(AccessControlException success) {
433	+	} catch(Exception ex) {
434	+	unexpectedException();
435	+	}
436	+	finally {
437	+	Policy.setPolicy(savedPolicy);
438	+	}
439	+	}
440	+
441	+	/**
442	+	* Without class loader permissions, calling
443	+	* privilegedCallableUsingCurrentClassLoader throws ACE
444	+	*/
445	+	public void testprivilegedCallableUsingCCLWithPrivs() {
446	+	Policy savedPolicy = Policy.getPolicy();
447	+	AdjustablePolicy policy = new AdjustablePolicy();
448	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
449	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
450	+	Policy.setPolicy(policy);
451	+	try {
452	+	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
453	+	task.call();
454	+	} catch(Exception ex) {
455	+	unexpectedException();
456	+	}
457	+	finally {
458	+	Policy.setPolicy(savedPolicy);
459	+	}
460	+	}
461	+
462	+	/**
463	+	* Without permissions, calling privilegedCallable throws ACE
464	+	*/
465	+	public void testprivilegedCallableWithNoPrivs() {
466	+	Policy savedPolicy = Policy.getPolicy();
467	+	AdjustablePolicy policy = new AdjustablePolicy();
468	+	Policy.setPolicy(policy);
469	+	Callable task = Executors.privilegedCallable(new CheckCCL());
470	+	Policy.setPolicy(savedPolicy);
471	+	try {
472	+	task.call();
473	+	shouldThrow();
474	+	} catch(AccessControlException success) {
475	+	} catch(Exception ex) {
476	+	unexpectedException();
477	+	} finally {
478	+	}
479	+	}
480	+
481	+	/**
482	+	* With permissions, calling privilegedCallable succeeds
483	+	*/
484	+	public void testprivilegedCallableWithPrivs() {
485	+	Policy savedPolicy = Policy.getPolicy();
486	+	AdjustablePolicy policy = new AdjustablePolicy();
487	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
488	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
489	+	Policy.setPolicy(policy);
490	+	Callable task = Executors.privilegedCallable(new CheckCCL());
491	+	try {
492	+	task.call();
493	+	} catch(Exception ex) {
494	+	unexpectedException();
495	+	} finally {
496	+	Policy.setPolicy(savedPolicy);
497	+	}
498	+	}
499	+
500	+	/**
501	+	* callable(Runnable) returns null when called
502	+	*/
503	+	public void testCallable1() {
504	+	try {
505	+	Callable c = Executors.callable(new NoOpRunnable());
506	+	assertNull(c.call());
507	+	} catch(Exception ex) {
508	+	unexpectedException();
509	+	}
510	+
511	+	}
512	+
513	+	/**
514	+	* callable(Runnable, result) returns result when called
515	+	*/
516	+	public void testCallable2() {
517	+	try {
518	+	Callable c = Executors.callable(new NoOpRunnable(), one);
519	+	assertEquals(one, c.call());
520	+	} catch(Exception ex) {
521	+	unexpectedException();
522	+	}
523	+	}
524	+
525	+	/**
526	+	* callable(PrivilegedAction) returns its result when called
527	+	*/
528	+	public void testCallable3() {
529	+	try {
530	+	Callable c = Executors.callable(new PrivilegedAction() {
531	+	public Object run() { return one; }});
532	+	assertEquals(one, c.call());
533	+	} catch(Exception ex) {
534	+	unexpectedException();
535	+	}
536	+	}
537	+
538	+	/**
539	+	* callable(PrivilegedExceptionAction) returns its result when called
540	+	*/
541	+	public void testCallable4() {
542	+	try {
543	+	Callable c = Executors.callable(new PrivilegedExceptionAction() {
544	+	public Object run() { return one; }});
545	+	assertEquals(one, c.call());
546	+	} catch(Exception ex) {
547	+	unexpectedException();
548	+	}
549	+	}
550	+
551	+
552	+	/**
553	+	* callable(null Runnable) throws NPE
554	+	*/
555	+	public void testCallableNPE1() {
556	+	try {
557	+	Runnable r = null;
558	+	Callable c = Executors.callable(r);
559	+	} catch (NullPointerException success) {
560	+	}
561	+	}
562	+
563	+	/**
564	+	* callable(null, result) throws NPE
565	+	*/
566	+	public void testCallableNPE2() {
567	+	try {
568	+	Runnable r = null;
569	+	Callable c = Executors.callable(r, one);
570	+	} catch (NullPointerException success) {
571	+	}
572	+	}
573	+
574	+	/**
575	+	* callable(null PrivilegedAction) throws NPE
576	+	*/
577	+	public void testCallableNPE3() {
578	+	try {
579	+	PrivilegedAction r = null;
580	+	Callable c = Executors.callable(r);
581	+	} catch (NullPointerException success) {
582	+	}
583	+	}
584	+
585	+	/**
586	+	* callable(null PrivilegedExceptionAction) throws NPE
587	+	*/
588	+	public void testCallableNPE4() {
589	+	try {
590	+	PrivilegedExceptionAction r = null;
591	+	Callable c = Executors.callable(r);
592	+	} catch (NullPointerException success) {
593	+	}
594	+	}
595	+
596	+
597		}

Diff Legend

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