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.13 by dl, Mon Jan 19 15:49:02 2004 UTC vs.
Revision 1.21 by jsr166, Mon Nov 16 04:57:10 2009 UTC

#	Line 2 | Line 2
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.
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9
#	Line 15 | Line 15 | import java.security.*;
15
16		public class ExecutorsTest extends JSR166TestCase{
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run (suite());
19		}
20		public static Test suite() {
21		return new TestSuite(ExecutorsTest.class);
#	Line 25 | Line 25 | public class ExecutorsTest extends JSR16
25		private final ExecutorService exec;
26		private final Callable<T> func;
27		private final long msecs;
28	<
28	>
29		TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
30		this.exec = exec;
31		this.func = func;
32		this.msecs = msecs;
33		}
34	<
34	>
35		public T call() throws Exception {
36		Future<T> ftask = exec.submit(func);
37		try {
#	Line 69 | Line 69 | public class ExecutorsTest extends JSR16
69		e.execute(new NoOpRunnable());
70		e.execute(new NoOpRunnable());
71		e.execute(new NoOpRunnable());
72	<	e.shutdown();
72	>	joinPool(e);
73		}
74
75		/**
#	Line 80 | Line 80 | public class ExecutorsTest extends JSR16
80		e.execute(new NoOpRunnable());
81		e.execute(new NoOpRunnable());
82		e.execute(new NoOpRunnable());
83	<	e.shutdown();
83	>	joinPool(e);
84		}
85
86		/**
#	Line 91 | Line 91 | public class ExecutorsTest extends JSR16
91		ExecutorService e = Executors.newCachedThreadPool(null);
92		shouldThrow();
93		}
94	<	catch(NullPointerException success) {
94	>	catch (NullPointerException success) {
95		}
96		}
97
#	Line 104 | Line 104 | public class ExecutorsTest extends JSR16
104		e.execute(new NoOpRunnable());
105		e.execute(new NoOpRunnable());
106		e.execute(new NoOpRunnable());
107	<	e.shutdown();
107	>	joinPool(e);
108		}
109
110		/**
#	Line 115 | Line 115 | public class ExecutorsTest extends JSR16
115		e.execute(new NoOpRunnable());
116		e.execute(new NoOpRunnable());
117		e.execute(new NoOpRunnable());
118	<	e.shutdown();
118	>	joinPool(e);
119		}
120
121		/**
#	Line 126 | Line 126 | public class ExecutorsTest extends JSR16
126		ExecutorService e = Executors.newSingleThreadExecutor(null);
127		shouldThrow();
128		}
129	<	catch(NullPointerException success) {
129	>	catch (NullPointerException success) {
130		}
131		}
132
#	Line 152 | Line 152 | public class ExecutorsTest extends JSR16
152		e.execute(new NoOpRunnable());
153		e.execute(new NoOpRunnable());
154		e.execute(new NoOpRunnable());
155	<	e.shutdown();
155	>	joinPool(e);
156		}
157
158		/**
#	Line 163 | Line 163 | public class ExecutorsTest extends JSR16
163		e.execute(new NoOpRunnable());
164		e.execute(new NoOpRunnable());
165		e.execute(new NoOpRunnable());
166	<	e.shutdown();
166	>	joinPool(e);
167		}
168
169		/**
#	Line 174 | Line 174 | public class ExecutorsTest extends JSR16
174		ExecutorService e = Executors.newFixedThreadPool(2, null);
175		shouldThrow();
176		}
177	<	catch(NullPointerException success) {
177	>	catch (NullPointerException success) {
178		}
179		}
180
#	Line 186 | Line 186 | public class ExecutorsTest extends JSR16
186		ExecutorService e = Executors.newFixedThreadPool(0);
187		shouldThrow();
188		}
189	<	catch(IllegalArgumentException success) {
189	>	catch (IllegalArgumentException success) {
190		}
191		}
192
#	Line 199 | Line 199 | public class ExecutorsTest extends JSR16
199		e.execute(new NoOpRunnable());
200		e.execute(new NoOpRunnable());
201		e.execute(new NoOpRunnable());
202	<	e.shutdown();
202	>	joinPool(e);
203		}
204
205		/**
#	Line 237 | Line 237 | public class ExecutorsTest extends JSR16
237		Thread.sleep(MEDIUM_DELAY_MS);
238		assertTrue(callable.done);
239		assertEquals(Boolean.TRUE, f.get());
240	–	p1.shutdown();
240		joinPool(p1);
241	<	} catch(RejectedExecutionException e){}
242	<	catch(Exception e){
241	>	} catch (RejectedExecutionException e){}
242	>	catch (Exception e){
243		e.printStackTrace();
244		unexpectedException();
245		}
#	Line 258 | Line 257 | public class ExecutorsTest extends JSR16
257		Thread.sleep(MEDIUM_DELAY_MS);
258		assertTrue(callable.done);
259		assertEquals(Boolean.TRUE, f.get());
261	–	p1.shutdown();
260		joinPool(p1);
261	<	} catch(RejectedExecutionException e){}
262	<	catch(Exception e){
261	>	} catch (RejectedExecutionException e){}
262	>	catch (Exception e){
263		e.printStackTrace();
264		unexpectedException();
265		}
#	Line 279 | Line 277 | public class ExecutorsTest extends JSR16
277		Thread.sleep(MEDIUM_DELAY_MS);
278		assertTrue(callable.done);
279		assertEquals(Boolean.TRUE, f.get());
282	–	p1.shutdown();
280		joinPool(p1);
281	<	} catch(RejectedExecutionException e){}
282	<	catch(Exception e){
281	>	} catch (RejectedExecutionException e){}
282	>	catch (Exception e){
283		e.printStackTrace();
284		unexpectedException();
285		}
#	Line 297 | Line 294 | public class ExecutorsTest extends JSR16
294		List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
295		try {
296		long startTime = System.currentTimeMillis();
297	<
297	>
298		long i = 0;
299		while (tasks.size() < N) {
300		tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
301		i += 10;
302		}
303	<
303	>
304		int iters = 0;
305		BigInteger sum = BigInteger.ZERO;
306		for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
#	Line 328 | Line 325 | public class ExecutorsTest extends JSR16
325		}
326		}
327
328	<
328	>
329		/**
330		* ThreadPoolExecutor using defaultThreadFactory has
331		* specified group, priority, daemon status, and name
#	Line 340 | Line 337 | public class ExecutorsTest extends JSR16
337		try {
338		Thread current = Thread.currentThread();
339		threadAssertTrue(!current.isDaemon());
340	<	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
340	>	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
341		ThreadGroup g = current.getThreadGroup();
342		SecurityManager s = System.getSecurityManager();
343		if (s != null)
#	Line 355 | Line 352 | public class ExecutorsTest extends JSR16
352		}
353		};
354		ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
355	<
355	>
356		e.execute(r);
357	<	e.shutdown();
357	>	try {
358	>	e.shutdown();
359	>	} catch (SecurityException ok) {
360	>	}
361	>
362		try {
363		Thread.sleep(SHORT_DELAY_MS);
364		} catch (Exception eX) {
#	Line 373 | Line 374 | public class ExecutorsTest extends JSR16
374		* access control context and context class loader
375		*/
376		public void testPrivilegedThreadFactory() {
377	<	Policy savedPolicy = Policy.getPolicy();
378	<	AdjustablePolicy policy = new AdjustablePolicy();
379	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
380	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
381	<	Policy.setPolicy(policy);
377	>	Policy savedPolicy = null;
378	>	try {
379	>	savedPolicy = Policy.getPolicy();
380	>	AdjustablePolicy policy = new AdjustablePolicy();
381	>	policy.addPermission(new RuntimePermission("getContextClassLoader"));
382	>	policy.addPermission(new RuntimePermission("setContextClassLoader"));
383	>	Policy.setPolicy(policy);
384	>	} catch (AccessControlException ok) {
385	>	return;
386	>	}
387		final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
388		final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
389		final AccessControlContext thisacc = AccessController.getContext();
#	Line 386 | Line 392 | public class ExecutorsTest extends JSR16
392		try {
393		Thread current = Thread.currentThread();
394		threadAssertTrue(!current.isDaemon());
395	<	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
395	>	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
396		ThreadGroup g = current.getThreadGroup();
397		SecurityManager s = System.getSecurityManager();
398		if (s != null)
#	Line 397 | Line 403 | public class ExecutorsTest extends JSR16
403		threadAssertTrue(name.endsWith("thread-1"));
404		threadAssertTrue(thisccl == current.getContextClassLoader());
405		threadAssertTrue(thisacc.equals(AccessController.getContext()));
406	<	} catch(SecurityException ok) {
406	>	} catch (SecurityException ok) {
407		// Also pass if not allowed to change settings
408		}
409	+	}
410		};
411		ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
412	<
412	>
413		Policy.setPolicy(savedPolicy);
414		e.execute(r);
415	<	e.shutdown();
415	>	try {
416	>	e.shutdown();
417	>	} catch (SecurityException ok) {
418	>	}
419		try {
420		Thread.sleep(SHORT_DELAY_MS);
421		} catch (Exception ex) {
#	Line 416 | Line 426 | public class ExecutorsTest extends JSR16
426
427		}
428
429	<	static class CheckCCL implements Callable<Object> {
429	>	void checkCCL() {
430	>	SecurityManager sm = System.getSecurityManager();
431	>	if (sm != null) {
432	>	sm.checkPermission(new RuntimePermission("setContextClassLoader"));
433	>	sm.checkPermission(new RuntimePermission("getClassLoader"));
434	>	}
435	>	}
436	>
437	>	class CheckCCL implements Callable<Object> {
438		public Object call() {
439	<	AccessControlContext acc = AccessController.getContext();
422	<	acc.checkPermission(new RuntimePermission("getContextClassLoader"));
439	>	checkCCL();
440		return null;
441		}
442		}
#	Line 430 | Line 447 | public class ExecutorsTest extends JSR16
447		* privilegedCallableUsingCurrentClassLoader throws ACE
448		*/
449		public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
450	<	Policy savedPolicy = Policy.getPolicy();
451	<	AdjustablePolicy policy = new AdjustablePolicy();
452	<	Policy.setPolicy(policy);
450	>	Policy savedPolicy = null;
451	>	try {
452	>	savedPolicy = Policy.getPolicy();
453	>	AdjustablePolicy policy = new AdjustablePolicy();
454	>	Policy.setPolicy(policy);
455	>	} catch (AccessControlException ok) {
456	>	return;
457	>	}
458	>
459	>	// Check if program still has too many permissions to run test
460	>	try {
461	>	checkCCL();
462	>	// too many privileges to test; so return
463	>	Policy.setPolicy(savedPolicy);
464	>	return;
465	>	} catch (AccessControlException ok) {
466	>	}
467	>
468		try {
469		Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
470		shouldThrow();
471	<	} catch(AccessControlException success) {
472	<	} catch(Exception ex) {
471	>	} catch (AccessControlException success) {
472	>	} catch (Exception ex) {
473		unexpectedException();
474	<	}
474	>	}
475		finally {
476		Policy.setPolicy(savedPolicy);
477		}
478		}
479
480		/**
481	<	* Without class loader permissions, calling
482	<	* privilegedCallableUsingCurrentClassLoader throws ACE
481	>	* With class loader permissions, calling
482	>	* privilegedCallableUsingCurrentClassLoader does not throw ACE
483		*/
484		public void testprivilegedCallableUsingCCLWithPrivs() {
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);
485	>	Policy savedPolicy = null;
486	>	try {
487	>	savedPolicy = Policy.getPolicy();
488	>	AdjustablePolicy policy = new AdjustablePolicy();
489	>	policy.addPermission(new RuntimePermission("getContextClassLoader"));
490	>	policy.addPermission(new RuntimePermission("setContextClassLoader"));
491	>	Policy.setPolicy(policy);
492	>	} catch (AccessControlException ok) {
493	>	return;
494	>	}
495	>
496		try {
497		Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
498		task.call();
499	<	} catch(Exception ex) {
499	>	} catch (Exception ex) {
500		unexpectedException();
501	<	}
501	>	}
502		finally {
503		Policy.setPolicy(savedPolicy);
504		}
#	Line 470 | Line 508 | public class ExecutorsTest extends JSR16
508		* Without permissions, calling privilegedCallable throws ACE
509		*/
510		public void testprivilegedCallableWithNoPrivs() {
511	<	Policy savedPolicy = Policy.getPolicy();
512	<	AdjustablePolicy policy = new AdjustablePolicy();
513	<	Policy.setPolicy(policy);
514	<	Callable task = Executors.privilegedCallable(new CheckCCL());
515	<	Policy.setPolicy(savedPolicy);
511	>	Callable task;
512	>	Policy savedPolicy = null;
513	>	AdjustablePolicy policy = null;
514	>	AccessControlContext noprivAcc = null;
515	>	try {
516	>	savedPolicy = Policy.getPolicy();
517	>	policy = new AdjustablePolicy();
518	>	Policy.setPolicy(policy);
519	>	noprivAcc = AccessController.getContext();
520	>	task = Executors.privilegedCallable(new CheckCCL());
521	>	Policy.setPolicy(savedPolicy);
522	>	} catch (AccessControlException ok) {
523	>	return; // program has too few permissions to set up test
524	>	}
525	>
526	>	// Make sure that program doesn't have too many permissions
527	>	try {
528	>	AccessController.doPrivileged(new PrivilegedAction() {
529	>	public Object run() {
530	>	checkCCL();
531	>	return null;
532	>	}}, noprivAcc);
533	>	// too many permssions; skip test
534	>	return;
535	>	} catch (AccessControlException ok) {
536	>	}
537	>
538		try {
539		task.call();
540		shouldThrow();
541	<	} catch(AccessControlException success) {
542	<	} catch(Exception ex) {
541	>	} catch (AccessControlException success) {
542	>	} catch (Exception ex) {
543		unexpectedException();
484	–	} finally {
544		}
545		}
546
#	Line 489 | Line 548 | public class ExecutorsTest extends JSR16
548		* With permissions, calling privilegedCallable succeeds
549		*/
550		public void testprivilegedCallableWithPrivs() {
551	<	Policy savedPolicy = Policy.getPolicy();
552	<	AdjustablePolicy policy = new AdjustablePolicy();
553	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
554	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
555	<	Policy.setPolicy(policy);
551	>	Policy savedPolicy = null;
552	>	try {
553	>	savedPolicy = Policy.getPolicy();
554	>	AdjustablePolicy policy = new AdjustablePolicy();
555	>	policy.addPermission(new RuntimePermission("getContextClassLoader"));
556	>	policy.addPermission(new RuntimePermission("setContextClassLoader"));
557	>	Policy.setPolicy(policy);
558	>	} catch (AccessControlException ok) {
559	>	return;
560	>	}
561	>
562		Callable task = Executors.privilegedCallable(new CheckCCL());
563		try {
564		task.call();
565	<	} catch(Exception ex) {
565	>	} catch (Exception ex) {
566		unexpectedException();
567		} finally {
568		Policy.setPolicy(savedPolicy);
#	Line 506 | Line 571 | public class ExecutorsTest extends JSR16
571
572		/**
573		* callable(Runnable) returns null when called
574	<	*/
574	>	*/
575		public void testCallable1() {
576		try {
577		Callable c = Executors.callable(new NoOpRunnable());
578		assertNull(c.call());
579	<	} catch(Exception ex) {
579	>	} catch (Exception ex) {
580		unexpectedException();
581		}
582	<
582	>
583		}
584
585		/**
586		* callable(Runnable, result) returns result when called
587	<	*/
587	>	*/
588		public void testCallable2() {
589		try {
590		Callable c = Executors.callable(new NoOpRunnable(), one);
591		assertEquals(one, c.call());
592	<	} catch(Exception ex) {
592	>	} catch (Exception ex) {
593		unexpectedException();
594		}
595		}
596
597		/**
598		* callable(PrivilegedAction) returns its result when called
599	<	*/
599	>	*/
600		public void testCallable3() {
601		try {
602		Callable c = Executors.callable(new PrivilegedAction() {
603		public Object run() { return one; }});
604		assertEquals(one, c.call());
605	<	} catch(Exception ex) {
605	>	} catch (Exception ex) {
606		unexpectedException();
607		}
608		}
609
610		/**
611		* callable(PrivilegedExceptionAction) returns its result when called
612	<	*/
612	>	*/
613		public void testCallable4() {
614		try {
615		Callable c = Executors.callable(new PrivilegedExceptionAction() {
616		public Object run() { return one; }});
617		assertEquals(one, c.call());
618	<	} catch(Exception ex) {
618	>	} catch (Exception ex) {
619		unexpectedException();
620		}
621		}
#	Line 558 | Line 623 | public class ExecutorsTest extends JSR16
623
624		/**
625		* callable(null Runnable) throws NPE
626	<	*/
626	>	*/
627		public void testCallableNPE1() {
628		try {
629		Runnable r = null;
#	Line 569 | Line 634 | public class ExecutorsTest extends JSR16
634
635		/**
636		* callable(null, result) throws NPE
637	<	*/
637	>	*/
638		public void testCallableNPE2() {
639		try {
640		Runnable r = null;
#	Line 580 | Line 645 | public class ExecutorsTest extends JSR16
645
646		/**
647		* callable(null PrivilegedAction) throws NPE
648	<	*/
648	>	*/
649		public void testCallableNPE3() {
650		try {
651		PrivilegedAction r = null;
#	Line 591 | Line 656 | public class ExecutorsTest extends JSR16
656
657		/**
658		* callable(null PrivilegedExceptionAction) throws NPE
659	<	*/
659	>	*/
660		public void testCallableNPE4() {
661		try {
662		PrivilegedExceptionAction r = null;

Diff Legend

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