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.15 by dl, Thu Jan 22 14:07:50 2004 UTC vs.
Revision 1.20 by jsr166, Wed Aug 5 00:40:11 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 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) {
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 409 | Line 409 | public class ExecutorsTest extends JSR16
409		}
410		};
411		ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
412	<
412	>
413		Policy.setPolicy(savedPolicy);
414		e.execute(r);
415		try {
#	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) {
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) {
500		unexpectedException();
501	<	}
501	>	}
502		finally {
503		Policy.setPolicy(savedPolicy);
504		}
505		}
506
491	–	class CallCCL implements Runnable {
492	–	final Callable task;
493	–	CallCCL(Callable t) { task = t; }
494	–	public void run() {
495	–	try {
496	–	task.call();
497	–	threadShouldThrow();
498	–	} catch(AccessControlException success) {
499	–	} catch(Exception ex) {
500	–	threadUnexpectedException();
501	–	}
502	–	}
503	–	}
504	–
507		/**
508		* Without permissions, calling privilegedCallable throws ACE
509		*/
510		public void testprivilegedCallableWithNoPrivs() {
511	<	Thread t1;
511	>	Callable task;
512	>	Policy savedPolicy = null;
513	>	AdjustablePolicy policy = null;
514	>	AccessControlContext noprivAcc = null;
515		try {
516	<	Policy savedPolicy = Policy.getPolicy();
517	<	AdjustablePolicy policy = new AdjustablePolicy();
516	>	savedPolicy = Policy.getPolicy();
517	>	policy = new AdjustablePolicy();
518		Policy.setPolicy(policy);
519	<	Callable task = Executors.privilegedCallable(new CheckCCL());
520	<	t1 = new Thread(new CallCCL(task));
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	<	t1.start();
540	<	t1.join();
539	>	task.call();
540	>	shouldThrow();
541	>	} catch(AccessControlException success) {
542		} catch(Exception ex) {
543		unexpectedException();
544	<	}
544	>	}
545		}
546
547		/**
#	Line 540 | 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();
#	Line 553 | 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());
#	Line 561 | Line 579 | public class ExecutorsTest extends JSR16
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);
#	Line 578 | Line 596 | public class ExecutorsTest extends JSR16
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() {
#	Line 591 | Line 609 | public class ExecutorsTest extends JSR16
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() {
#	Line 605 | 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 616 | 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 627 | 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 638 | 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