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.11 by dl, Mon Dec 22 00:48:55 2003 UTC

#	Line 130 | 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 177 | Line 191 | public class ExecutorsTest extends JSR16
191
192
193		/**
194	+	* An unconfigurable newFixedThreadPool can execute runnables
195	+	*/
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	+	* unconfigurableExecutorService(null) throws NPE
206	+	*/
207	+	public void testunconfigurableExecutorServiceNPE() {
208	+	try {
209	+	ExecutorService e = Executors.unconfigurableExecutorService(null);
210	+	}
211	+	catch (NullPointerException success) {
212	+	}
213	+	}
214	+
215	+	/**
216	+	* unconfigurableScheduledExecutorService(null) throws NPE
217	+	*/
218	+	public void testunconfigurableScheduledExecutorServiceNPE() {
219	+	try {
220	+	ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
221	+	}
222	+	catch (NullPointerException success) {
223	+	}
224	+	}
225	+
226	+
227	+	/**
228	+	* a newSingleThreadScheduledExecutor successfully runs delayed task
229	+	*/
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	+	* 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	+	* 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	+	}
288	+	}
289	+
290	+	/**
291		*  timeouts from execute will time out if they compute too long.
292		*/
293		public void testTimedCallable() {
#	Line 297 | 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