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.14 by dl, Tue Jan 20 20:20:56 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 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 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 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 238 | Line 238 | public class ExecutorsTest extends JSR16
238		assertTrue(callable.done);
239		assertEquals(Boolean.TRUE, f.get());
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 258 | public class ExecutorsTest extends JSR16
258		assertTrue(callable.done);
259		assertEquals(Boolean.TRUE, f.get());
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 278 | Line 278 | public class ExecutorsTest extends JSR16
278		assertTrue(callable.done);
279		assertEquals(Boolean.TRUE, f.get());
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 294 | 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 325 | 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 337 | 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 352 | Line 352 | public class ExecutorsTest extends JSR16
352		}
353		};
354		ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
355	<
355	>
356		e.execute(r);
357		try {
358		e.shutdown();
359	<	} catch(SecurityException ok) {
359	>	} catch (SecurityException ok) {
360		}
361	<
361	>
362		try {
363		Thread.sleep(SHORT_DELAY_MS);
364		} catch (Exception eX) {
#	Line 392 | 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 403 | 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		try {
416		e.shutdown();
417	<	} catch(SecurityException ok) {
417	>	} catch (SecurityException ok) {
418		}
419		try {
420		Thread.sleep(SHORT_DELAY_MS);
#	Line 426 | 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();
432	<	acc.checkPermission(new RuntimePermission("getContextClassLoader"));
439	>	checkCCL();
440		return null;
441		}
442		}
#	Line 449 | Line 456 | public class ExecutorsTest extends JSR16
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 = null;
#	Line 476 | Line 492 | public class ExecutorsTest extends JSR16
492		} catch (AccessControlException ok) {
493		return;
494		}
495	<
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 492 | Line 508 | public class ExecutorsTest extends JSR16
508		* Without permissions, calling privilegedCallable throws ACE
509		*/
510		public void testprivilegedCallableWithNoPrivs() {
511	<	Policy savedPolicy = null;
511	>	Callable task;
512	>	Policy savedPolicy = null;
513	>	AdjustablePolicy policy = null;
514	>	AccessControlContext noprivAcc = null;
515		try {
516		savedPolicy = Policy.getPolicy();
517	<	AdjustablePolicy policy = new AdjustablePolicy();
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
504	–	Callable task = Executors.privilegedCallable(new CheckCCL());
505	–	Policy.setPolicy(savedPolicy);
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();
512	–	} finally {
544		}
545		}
546
#	Line 527 | Line 558 | public class ExecutorsTest extends JSR16
558		} catch (AccessControlException ok) {
559		return;
560		}
561	<
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 540 | 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 592 | 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 603 | 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 614 | 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 625 | 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