test/tck/ExecutorsTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes, 
 * Pat Fisher, Mike Judd. 
 */


import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.math.BigInteger;
import java.security.*;
import sun.security.util.SecurityConstants;

public class ExecutorsTest extends JSR166TestCase{
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    public static Test suite() {
        return new TestSuite(ExecutorsTest.class);
    }

    static class TimedCallable<T> implements Callable<T> {
        private final ExecutorService exec;
        private final Callable<T> func;
        private final long msecs;
        
        TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
            this.exec = exec;
            this.func = func;
            this.msecs = msecs;
        }
        
        public T call() throws Exception {
            Future<T> ftask = exec.submit(func);
            try {
                return ftask.get(msecs, TimeUnit.MILLISECONDS);
            } finally {
                ftask.cancel(true);
            }
        }
    }


    private static class Fib implements Callable<BigInteger> {
        private final BigInteger n;
        Fib(long n) {
            if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
            this.n = BigInteger.valueOf(n);
        }
        public BigInteger call() {
            BigInteger f1 = BigInteger.ONE;
            BigInteger f2 = f1;
            for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
                BigInteger t = f1.add(f2);
                f1 = f2;
                f2 = t;
            }
            return f1;
        }
    };

    /**
     * A newCachedThreadPool can execute runnables
     */
    public void testNewCachedThreadPool1() {
        ExecutorService e = Executors.newCachedThreadPool();
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        joinPool(e);
    }

    /**
     * A newCachedThreadPool with given ThreadFactory can execute runnables
     */
    public void testNewCachedThreadPool2() {
        ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        joinPool(e);
    }

    /**
     * A newCachedThreadPool with null ThreadFactory throws NPE
     */
    public void testNewCachedThreadPool3() {
        try {
            ExecutorService e = Executors.newCachedThreadPool(null);
            shouldThrow();
        }
        catch(NullPointerException success) {
        }
    }


    /**
     * A new SingleThreadExecutor can execute runnables
     */
    public void testNewSingleThreadExecutor1() {
        ExecutorService e = Executors.newSingleThreadExecutor();
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        joinPool(e);
    }

    /**
     * A new SingleThreadExecutor with given ThreadFactory can execute runnables
     */
    public void testNewSingleThreadExecutor2() {
        ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        joinPool(e);
    }

    /**
     * A new SingleThreadExecutor with null ThreadFactory throws NPE
     */
    public void testNewSingleThreadExecutor3() {
        try {
            ExecutorService e = Executors.newSingleThreadExecutor(null);
            shouldThrow();
        }
        catch(NullPointerException success) {
        }
    }

    /**
     * A new SingleThreadExecutor cannot be casted to concrete implementation
     */
    public void testCastNewSingleThreadExecutor() {
        ExecutorService e = Executors.newSingleThreadExecutor();
        try {
            ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
        } catch (ClassCastException success) {
        } finally {
            joinPool(e);
        }
    }


    /**
     * A new newFixedThreadPool can execute runnables
     */
    public void testNewFixedThreadPool1() {
        ExecutorService e = Executors.newFixedThreadPool(2);
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        joinPool(e);
    }

    /**
     * A new newFixedThreadPool with given ThreadFactory can execute runnables
     */
    public void testNewFixedThreadPool2() {
        ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        joinPool(e);
    }

    /**
     * A new newFixedThreadPool with null ThreadFactory throws NPE
     */
    public void testNewFixedThreadPool3() {
        try {
            ExecutorService e = Executors.newFixedThreadPool(2, null);
            shouldThrow();
        }
        catch(NullPointerException success) {
        }
    }

    /**
     * A new newFixedThreadPool with 0 threads throws IAE
     */
    public void testNewFixedThreadPool4() {
        try {
            ExecutorService e = Executors.newFixedThreadPool(0);
            shouldThrow();
        }
        catch(IllegalArgumentException success) {
        }
    }


    /**
     * An unconfigurable newFixedThreadPool can execute runnables
     */
    public void testunconfigurableExecutorService() {
        ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        e.execute(new NoOpRunnable());
        joinPool(e);
    }

    /**
     * unconfigurableExecutorService(null) throws NPE
     */
    public void testunconfigurableExecutorServiceNPE() {
        try {
            ExecutorService e = Executors.unconfigurableExecutorService(null);
        }
        catch (NullPointerException success) {
        }
    }

    /**
     * unconfigurableScheduledExecutorService(null) throws NPE
     */
    public void testunconfigurableScheduledExecutorServiceNPE() {
        try {
            ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
        }
        catch (NullPointerException success) {
        }
    }


    /**
     * a newSingleThreadScheduledExecutor successfully runs delayed task
     */
    public void testNewSingleThreadScheduledExecutor() {
        try {
            TrackedCallable callable = new TrackedCallable();
            ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
            Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
            assertFalse(callable.done);
            Thread.sleep(MEDIUM_DELAY_MS);
            assertTrue(callable.done);
            assertEquals(Boolean.TRUE, f.get());
            joinPool(p1);
        } catch(RejectedExecutionException e){}
        catch(Exception e){
            e.printStackTrace();
            unexpectedException();
        }
    }

    /**
     * a newScheduledThreadPool successfully runs delayed task
     */
    public void testnewScheduledThreadPool() {
        try {
            TrackedCallable callable = new TrackedCallable();
            ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
            Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
            assertFalse(callable.done);
            Thread.sleep(MEDIUM_DELAY_MS);
            assertTrue(callable.done);
            assertEquals(Boolean.TRUE, f.get());
            joinPool(p1);
        } catch(RejectedExecutionException e){}
        catch(Exception e){
            e.printStackTrace();
            unexpectedException();
        }
    }

    /**
     * an unconfigurable  newScheduledThreadPool successfully runs delayed task
     */
    public void testunconfigurableScheduledExecutorService() {
        try {
            TrackedCallable callable = new TrackedCallable();
            ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
            Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
            assertFalse(callable.done);
            Thread.sleep(MEDIUM_DELAY_MS);
            assertTrue(callable.done);
            assertEquals(Boolean.TRUE, f.get());
            joinPool(p1);
        } catch(RejectedExecutionException e){}
        catch(Exception e){
            e.printStackTrace();
            unexpectedException();
        }
    }

    /**
     *  timeouts from execute will time out if they compute too long.
     */
    public void testTimedCallable() {
        int N = 10000;
        ExecutorService executor = Executors.newSingleThreadExecutor();
        List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
        try {
            long startTime = System.currentTimeMillis();
            
            long i = 0;
            while (tasks.size() < N) {
                tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
                i += 10;
            }
            
            int iters = 0;
            BigInteger sum = BigInteger.ZERO;
            for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
                try {
                    ++iters;
                    sum = sum.add(it.next().call());
                }
                catch (TimeoutException success) {
                    assertTrue(iters > 0);
                    return;
                }
                catch (Exception e) {
                    unexpectedException();
                }
            }
            // if by chance we didn't ever time out, total time must be small
            long elapsed = System.currentTimeMillis() - startTime;
            assertTrue(elapsed < N);
        }
        finally {
            joinPool(executor);
        }
    }

    
    /**
     * ThreadPoolExecutor using defaultThreadFactory has
     * specified group, priority, daemon status, and name
     */
    public void testDefaultThreadFactory() {
        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
        Runnable r = new Runnable() {
                public void run() {
                    try {
                        Thread current = Thread.currentThread();
                        threadAssertTrue(!current.isDaemon());
                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
                        ThreadGroup g = current.getThreadGroup();
                        SecurityManager s = System.getSecurityManager();
                        if (s != null)
                            threadAssertTrue(g == s.getThreadGroup());
                        else
                            threadAssertTrue(g == egroup);
                        String name = current.getName();
                        threadAssertTrue(name.endsWith("thread-1"));
                    } catch (SecurityException ok) {
                        // Also pass if not allowed to change setting
                    }
                }
            };
        ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
        
        e.execute(r);
        try {
            e.shutdown();
        } catch(SecurityException ok) {
        }
        
        try {
            Thread.sleep(SHORT_DELAY_MS);
        } catch (Exception eX) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * ThreadPoolExecutor using privilegedThreadFactory has
     * specified group, priority, daemon status, name,
     * access control context and context class loader
     */
    public void testPrivilegedThreadFactory() {
        Policy savedPolicy = null;
        try {
            savedPolicy = Policy.getPolicy();
            AdjustablePolicy policy = new AdjustablePolicy();
            policy.addPermission(new RuntimePermission("getContextClassLoader"));
            policy.addPermission(new RuntimePermission("setContextClassLoader"));
            Policy.setPolicy(policy);
        } catch (AccessControlException ok) {
            return;
        }
        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
        final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
        final AccessControlContext thisacc = AccessController.getContext();
        Runnable r = new Runnable() {
                public void run() {
                    try {
                        Thread current = Thread.currentThread();
                        threadAssertTrue(!current.isDaemon());
                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
                        ThreadGroup g = current.getThreadGroup();
                        SecurityManager s = System.getSecurityManager();
                        if (s != null)
                            threadAssertTrue(g == s.getThreadGroup());
                        else
                            threadAssertTrue(g == egroup);
                        String name = current.getName();
                        threadAssertTrue(name.endsWith("thread-1"));
                        threadAssertTrue(thisccl == current.getContextClassLoader());
                        threadAssertTrue(thisacc.equals(AccessController.getContext()));
                    } catch(SecurityException ok) {
                        // Also pass if not allowed to change settings
                    }
                }
            };
        ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
        
        Policy.setPolicy(savedPolicy);
        e.execute(r);
        try {
            e.shutdown();
        } catch(SecurityException ok) {
        }
        try {
            Thread.sleep(SHORT_DELAY_MS);
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }

    }

    void checkCCL() {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
            sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
        }
    }

    class CheckCCL implements Callable<Object> {
        public Object call() {
            checkCCL();
            return null;
        }
    }


    /**
     * Without class loader permissions, creating
     * privilegedCallableUsingCurrentClassLoader throws ACE
     */
    public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
        Policy savedPolicy = null;
        try {
            savedPolicy = Policy.getPolicy();
            AdjustablePolicy policy = new AdjustablePolicy();
            Policy.setPolicy(policy);
        } catch (AccessControlException ok) {
            return;
        }

        // Check if program still has too many permissions to run test
        try {
            checkCCL();
            // too many privileges to test; so return
            Policy.setPolicy(savedPolicy);
            return;
        } catch(AccessControlException ok) {
        } 

        try {
            Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
            shouldThrow();
        } catch(AccessControlException success) {
        } catch(Exception ex) {
            unexpectedException();
        } 
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * With class loader permissions, calling
     * privilegedCallableUsingCurrentClassLoader does not throw ACE
     */
    public void testprivilegedCallableUsingCCLWithPrivs() {
        Policy savedPolicy = null;
        try {
            savedPolicy = Policy.getPolicy();
            AdjustablePolicy policy = new AdjustablePolicy();
            policy.addPermission(new RuntimePermission("getContextClassLoader"));
            policy.addPermission(new RuntimePermission("setContextClassLoader"));
            Policy.setPolicy(policy);
        } catch (AccessControlException ok) {
            return;
        }
            
        try {
            Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
            task.call();
        } catch(Exception ex) {
            unexpectedException();
        } 
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * Without permissions, calling privilegedCallable throws ACE
     */
    public void testprivilegedCallableWithNoPrivs() {
        Callable task;
        Policy savedPolicy = null;
        AdjustablePolicy policy = null;
        AccessControlContext noprivAcc = null;
        try {
            savedPolicy = Policy.getPolicy();
            policy = new AdjustablePolicy();
            Policy.setPolicy(policy);
            noprivAcc = AccessController.getContext();
            task = Executors.privilegedCallable(new CheckCCL());
            Policy.setPolicy(savedPolicy);
        } catch (AccessControlException ok) {
            return; // program has too few permissions to set up test
        }

        // Make sure that program doesn't have too many permissions 
        try {
            AccessController.doPrivileged(new PrivilegedAction() {
                    public Object run() {
                        checkCCL();
                        return null;
                    }}, noprivAcc);
            // too many permssions; skip test
            return;
        } catch(AccessControlException ok) {
        }

        try {
            task.call();
            shouldThrow();
        } catch(AccessControlException success) {
        } catch(Exception ex) {
            unexpectedException();
        } 
    }

    /**
     * With permissions, calling privilegedCallable succeeds
     */
    public void testprivilegedCallableWithPrivs() {
        Policy savedPolicy = null;
        try {
            savedPolicy = Policy.getPolicy();
            AdjustablePolicy policy = new AdjustablePolicy();
            policy.addPermission(new RuntimePermission("getContextClassLoader"));
            policy.addPermission(new RuntimePermission("setContextClassLoader"));
            Policy.setPolicy(policy);
        } catch (AccessControlException ok) {
            return;
        }
            
        Callable task = Executors.privilegedCallable(new CheckCCL());
        try {
            task.call();
        } catch(Exception ex) {
            unexpectedException();
        } finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * callable(Runnable) returns null when called
     */ 
    public void testCallable1() {
        try {
            Callable c = Executors.callable(new NoOpRunnable());
            assertNull(c.call());
        } catch(Exception ex) {
            unexpectedException();
        }
        
    }

    /**
     * callable(Runnable, result) returns result when called
     */ 
    public void testCallable2() {
        try {
            Callable c = Executors.callable(new NoOpRunnable(), one);
            assertEquals(one, c.call());
        } catch(Exception ex) {
            unexpectedException();
        }
    }

    /**
     * callable(PrivilegedAction) returns its result when called
     */ 
    public void testCallable3() {
        try {
            Callable c = Executors.callable(new PrivilegedAction() {
                    public Object run() { return one; }});
        assertEquals(one, c.call());
        } catch(Exception ex) {
            unexpectedException();
        }
    }

    /**
     * callable(PrivilegedExceptionAction) returns its result when called
     */ 
    public void testCallable4() {
        try {
            Callable c = Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() { return one; }});
            assertEquals(one, c.call());
        } catch(Exception ex) {
            unexpectedException();
        }
    }


    /**
     * callable(null Runnable) throws NPE
     */ 
    public void testCallableNPE1() {
        try {
            Runnable r = null;
            Callable c = Executors.callable(r);
        } catch (NullPointerException success) {
        }
    }

    /**
     * callable(null, result) throws NPE
     */ 
    public void testCallableNPE2() {
        try {
            Runnable r = null;
            Callable c = Executors.callable(r, one);
        } catch (NullPointerException success) {
        }
    }

    /**
     * callable(null PrivilegedAction) throws NPE
     */ 
    public void testCallableNPE3() {
        try {
            PrivilegedAction r = null;
            Callable c = Executors.callable(r);
        } catch (NullPointerException success) {
        }
    }

    /**
     * callable(null PrivilegedExceptionAction) throws NPE
     */ 
    public void testCallableNPE4() {
        try {
            PrivilegedExceptionAction r = null;
            Callable c = Executors.callable(r);
        } catch (NullPointerException success) {
        }
    }


}
Revision:	1.18
Committed:	Tue Aug 4 13:58:09 2009 UTC (14 years, 9 months ago) by dl
Branch:	MAIN
Changes since 1.17:	+6 -1 lines
Log Message:	Track 1.6 change to use security manager, not AccessControl
#	Content
1	/*
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
10	import junit.framework.*;
11	import java.util.*;
12	import java.util.concurrent.*;
13	import java.math.BigInteger;
14	import java.security.*;
15	import sun.security.util.SecurityConstants;
16
17	public class ExecutorsTest extends JSR166TestCase{
18	public static void main(String[] args) {
19	junit.textui.TestRunner.run (suite());
20	}
21	public static Test suite() {
22	return new TestSuite(ExecutorsTest.class);
23	}
24
25	static class TimedCallable<T> implements Callable<T> {
26	private final ExecutorService exec;
27	private final Callable<T> func;
28	private final long msecs;
29
30	TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
31	this.exec = exec;
32	this.func = func;
33	this.msecs = msecs;
34	}
35
36	public T call() throws Exception {
37	Future<T> ftask = exec.submit(func);
38	try {
39	return ftask.get(msecs, TimeUnit.MILLISECONDS);
40	} finally {
41	ftask.cancel(true);
42	}
43	}
44	}
45
46
47	private static class Fib implements Callable<BigInteger> {
48	private final BigInteger n;
49	Fib(long n) {
50	if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
51	this.n = BigInteger.valueOf(n);
52	}
53	public BigInteger call() {
54	BigInteger f1 = BigInteger.ONE;
55	BigInteger f2 = f1;
56	for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
57	BigInteger t = f1.add(f2);
58	f1 = f2;
59	f2 = t;
60	}
61	return f1;
62	}
63	};
64
65	/**
66	* A newCachedThreadPool can execute runnables
67	*/
68	public void testNewCachedThreadPool1() {
69	ExecutorService e = Executors.newCachedThreadPool();
70	e.execute(new NoOpRunnable());
71	e.execute(new NoOpRunnable());
72	e.execute(new NoOpRunnable());
73	joinPool(e);
74	}
75
76	/**
77	* A newCachedThreadPool with given ThreadFactory can execute runnables
78	*/
79	public void testNewCachedThreadPool2() {
80	ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
81	e.execute(new NoOpRunnable());
82	e.execute(new NoOpRunnable());
83	e.execute(new NoOpRunnable());
84	joinPool(e);
85	}
86
87	/**
88	* A newCachedThreadPool with null ThreadFactory throws NPE
89	*/
90	public void testNewCachedThreadPool3() {
91	try {
92	ExecutorService e = Executors.newCachedThreadPool(null);
93	shouldThrow();
94	}
95	catch(NullPointerException success) {
96	}
97	}
98
99
100	/**
101	* A new SingleThreadExecutor can execute runnables
102	*/
103	public void testNewSingleThreadExecutor1() {
104	ExecutorService e = Executors.newSingleThreadExecutor();
105	e.execute(new NoOpRunnable());
106	e.execute(new NoOpRunnable());
107	e.execute(new NoOpRunnable());
108	joinPool(e);
109	}
110
111	/**
112	* A new SingleThreadExecutor with given ThreadFactory can execute runnables
113	*/
114	public void testNewSingleThreadExecutor2() {
115	ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
116	e.execute(new NoOpRunnable());
117	e.execute(new NoOpRunnable());
118	e.execute(new NoOpRunnable());
119	joinPool(e);
120	}
121
122	/**
123	* A new SingleThreadExecutor with null ThreadFactory throws NPE
124	*/
125	public void testNewSingleThreadExecutor3() {
126	try {
127	ExecutorService e = Executors.newSingleThreadExecutor(null);
128	shouldThrow();
129	}
130	catch(NullPointerException success) {
131	}
132	}
133
134	/**
135	* A new SingleThreadExecutor cannot be casted to concrete implementation
136	*/
137	public void testCastNewSingleThreadExecutor() {
138	ExecutorService e = Executors.newSingleThreadExecutor();
139	try {
140	ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
141	} catch (ClassCastException success) {
142	} finally {
143	joinPool(e);
144	}
145	}
146
147
148	/**
149	* A new newFixedThreadPool can execute runnables
150	*/
151	public void testNewFixedThreadPool1() {
152	ExecutorService e = Executors.newFixedThreadPool(2);
153	e.execute(new NoOpRunnable());
154	e.execute(new NoOpRunnable());
155	e.execute(new NoOpRunnable());
156	joinPool(e);
157	}
158
159	/**
160	* A new newFixedThreadPool with given ThreadFactory can execute runnables
161	*/
162	public void testNewFixedThreadPool2() {
163	ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
164	e.execute(new NoOpRunnable());
165	e.execute(new NoOpRunnable());
166	e.execute(new NoOpRunnable());
167	joinPool(e);
168	}
169
170	/**
171	* A new newFixedThreadPool with null ThreadFactory throws NPE
172	*/
173	public void testNewFixedThreadPool3() {
174	try {
175	ExecutorService e = Executors.newFixedThreadPool(2, null);
176	shouldThrow();
177	}
178	catch(NullPointerException success) {
179	}
180	}
181
182	/**
183	* A new newFixedThreadPool with 0 threads throws IAE
184	*/
185	public void testNewFixedThreadPool4() {
186	try {
187	ExecutorService e = Executors.newFixedThreadPool(0);
188	shouldThrow();
189	}
190	catch(IllegalArgumentException success) {
191	}
192	}
193
194
195	/**
196	* An unconfigurable newFixedThreadPool can execute runnables
197	*/
198	public void testunconfigurableExecutorService() {
199	ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
200	e.execute(new NoOpRunnable());
201	e.execute(new NoOpRunnable());
202	e.execute(new NoOpRunnable());
203	joinPool(e);
204	}
205
206	/**
207	* unconfigurableExecutorService(null) throws NPE
208	*/
209	public void testunconfigurableExecutorServiceNPE() {
210	try {
211	ExecutorService e = Executors.unconfigurableExecutorService(null);
212	}
213	catch (NullPointerException success) {
214	}
215	}
216
217	/**
218	* unconfigurableScheduledExecutorService(null) throws NPE
219	*/
220	public void testunconfigurableScheduledExecutorServiceNPE() {
221	try {
222	ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
223	}
224	catch (NullPointerException success) {
225	}
226	}
227
228
229	/**
230	* a newSingleThreadScheduledExecutor successfully runs delayed task
231	*/
232	public void testNewSingleThreadScheduledExecutor() {
233	try {
234	TrackedCallable callable = new TrackedCallable();
235	ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
236	Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
237	assertFalse(callable.done);
238	Thread.sleep(MEDIUM_DELAY_MS);
239	assertTrue(callable.done);
240	assertEquals(Boolean.TRUE, f.get());
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	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	joinPool(p1);
282	} catch(RejectedExecutionException e){}
283	catch(Exception e){
284	e.printStackTrace();
285	unexpectedException();
286	}
287	}
288
289	/**
290	* timeouts from execute will time out if they compute too long.
291	*/
292	public void testTimedCallable() {
293	int N = 10000;
294	ExecutorService executor = Executors.newSingleThreadExecutor();
295	List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
296	try {
297	long startTime = System.currentTimeMillis();
298
299	long i = 0;
300	while (tasks.size() < N) {
301	tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
302	i += 10;
303	}
304
305	int iters = 0;
306	BigInteger sum = BigInteger.ZERO;
307	for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
308	try {
309	++iters;
310	sum = sum.add(it.next().call());
311	}
312	catch (TimeoutException success) {
313	assertTrue(iters > 0);
314	return;
315	}
316	catch (Exception e) {
317	unexpectedException();
318	}
319	}
320	// if by chance we didn't ever time out, total time must be small
321	long elapsed = System.currentTimeMillis() - startTime;
322	assertTrue(elapsed < N);
323	}
324	finally {
325	joinPool(executor);
326	}
327	}
328
329
330	/**
331	* ThreadPoolExecutor using defaultThreadFactory has
332	* specified group, priority, daemon status, and name
333	*/
334	public void testDefaultThreadFactory() {
335	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
336	Runnable r = new Runnable() {
337	public void run() {
338	try {
339	Thread current = Thread.currentThread();
340	threadAssertTrue(!current.isDaemon());
341	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
342	ThreadGroup g = current.getThreadGroup();
343	SecurityManager s = System.getSecurityManager();
344	if (s != null)
345	threadAssertTrue(g == s.getThreadGroup());
346	else
347	threadAssertTrue(g == egroup);
348	String name = current.getName();
349	threadAssertTrue(name.endsWith("thread-1"));
350	} catch (SecurityException ok) {
351	// Also pass if not allowed to change setting
352	}
353	}
354	};
355	ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
356
357	e.execute(r);
358	try {
359	e.shutdown();
360	} catch(SecurityException ok) {
361	}
362
363	try {
364	Thread.sleep(SHORT_DELAY_MS);
365	} catch (Exception eX) {
366	unexpectedException();
367	} finally {
368	joinPool(e);
369	}
370	}
371
372	/**
373	* ThreadPoolExecutor using privilegedThreadFactory has
374	* specified group, priority, daemon status, name,
375	* access control context and context class loader
376	*/
377	public void testPrivilegedThreadFactory() {
378	Policy savedPolicy = null;
379	try {
380	savedPolicy = Policy.getPolicy();
381	AdjustablePolicy policy = new AdjustablePolicy();
382	policy.addPermission(new RuntimePermission("getContextClassLoader"));
383	policy.addPermission(new RuntimePermission("setContextClassLoader"));
384	Policy.setPolicy(policy);
385	} catch (AccessControlException ok) {
386	return;
387	}
388	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
389	final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
390	final AccessControlContext thisacc = AccessController.getContext();
391	Runnable r = new Runnable() {
392	public void run() {
393	try {
394	Thread current = Thread.currentThread();
395	threadAssertTrue(!current.isDaemon());
396	threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
397	ThreadGroup g = current.getThreadGroup();
398	SecurityManager s = System.getSecurityManager();
399	if (s != null)
400	threadAssertTrue(g == s.getThreadGroup());
401	else
402	threadAssertTrue(g == egroup);
403	String name = current.getName();
404	threadAssertTrue(name.endsWith("thread-1"));
405	threadAssertTrue(thisccl == current.getContextClassLoader());
406	threadAssertTrue(thisacc.equals(AccessController.getContext()));
407	} catch(SecurityException ok) {
408	// Also pass if not allowed to change settings
409	}
410	}
411	};
412	ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
413
414	Policy.setPolicy(savedPolicy);
415	e.execute(r);
416	try {
417	e.shutdown();
418	} catch(SecurityException ok) {
419	}
420	try {
421	Thread.sleep(SHORT_DELAY_MS);
422	} catch (Exception ex) {
423	unexpectedException();
424	} finally {
425	joinPool(e);
426	}
427
428	}
429
430	void checkCCL() {
431	SecurityManager sm = System.getSecurityManager();
432	if (sm != null) {
433	sm.checkPermission(new RuntimePermission("setContextClassLoader"));
434	sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
435	}
436	}
437
438	class CheckCCL implements Callable<Object> {
439	public Object call() {
440	checkCCL();
441	return null;
442	}
443	}
444
445
446	/**
447	* Without class loader permissions, creating
448	* privilegedCallableUsingCurrentClassLoader throws ACE
449	*/
450	public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
451	Policy savedPolicy = null;
452	try {
453	savedPolicy = Policy.getPolicy();
454	AdjustablePolicy policy = new AdjustablePolicy();
455	Policy.setPolicy(policy);
456	} catch (AccessControlException ok) {
457	return;
458	}
459
460	// Check if program still has too many permissions to run test
461	try {
462	checkCCL();
463	// too many privileges to test; so return
464	Policy.setPolicy(savedPolicy);
465	return;
466	} catch(AccessControlException ok) {
467	}
468
469	try {
470	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
471	shouldThrow();
472	} catch(AccessControlException success) {
473	} catch(Exception ex) {
474	unexpectedException();
475	}
476	finally {
477	Policy.setPolicy(savedPolicy);
478	}
479	}
480
481	/**
482	* With class loader permissions, calling
483	* privilegedCallableUsingCurrentClassLoader does not throw ACE
484	*/
485	public void testprivilegedCallableUsingCCLWithPrivs() {
486	Policy savedPolicy = null;
487	try {
488	savedPolicy = Policy.getPolicy();
489	AdjustablePolicy policy = new AdjustablePolicy();
490	policy.addPermission(new RuntimePermission("getContextClassLoader"));
491	policy.addPermission(new RuntimePermission("setContextClassLoader"));
492	Policy.setPolicy(policy);
493	} catch (AccessControlException ok) {
494	return;
495	}
496
497	try {
498	Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
499	task.call();
500	} catch(Exception ex) {
501	unexpectedException();
502	}
503	finally {
504	Policy.setPolicy(savedPolicy);
505	}
506	}
507
508	/**
509	* Without permissions, calling privilegedCallable throws ACE
510	*/
511	public void testprivilegedCallableWithNoPrivs() {
512	Callable task;
513	Policy savedPolicy = null;
514	AdjustablePolicy policy = null;
515	AccessControlContext noprivAcc = null;
516	try {
517	savedPolicy = Policy.getPolicy();
518	policy = new AdjustablePolicy();
519	Policy.setPolicy(policy);
520	noprivAcc = AccessController.getContext();
521	task = Executors.privilegedCallable(new CheckCCL());
522	Policy.setPolicy(savedPolicy);
523	} catch (AccessControlException ok) {
524	return; // program has too few permissions to set up test
525	}
526
527	// Make sure that program doesn't have too many permissions
528	try {
529	AccessController.doPrivileged(new PrivilegedAction() {
530	public Object run() {
531	checkCCL();
532	return null;
533	}}, noprivAcc);
534	// too many permssions; skip test
535	return;
536	} catch(AccessControlException ok) {
537	}
538
539	try {
540	task.call();
541	shouldThrow();
542	} catch(AccessControlException success) {
543	} catch(Exception ex) {
544	unexpectedException();
545	}
546	}
547
548	/**
549	* With permissions, calling privilegedCallable succeeds
550	*/
551	public void testprivilegedCallableWithPrivs() {
552	Policy savedPolicy = null;
553	try {
554	savedPolicy = Policy.getPolicy();
555	AdjustablePolicy policy = new AdjustablePolicy();
556	policy.addPermission(new RuntimePermission("getContextClassLoader"));
557	policy.addPermission(new RuntimePermission("setContextClassLoader"));
558	Policy.setPolicy(policy);
559	} catch (AccessControlException ok) {
560	return;
561	}
562
563	Callable task = Executors.privilegedCallable(new CheckCCL());
564	try {
565	task.call();
566	} catch(Exception ex) {
567	unexpectedException();
568	} finally {
569	Policy.setPolicy(savedPolicy);
570	}
571	}
572
573	/**
574	* callable(Runnable) returns null when called
575	*/
576	public void testCallable1() {
577	try {
578	Callable c = Executors.callable(new NoOpRunnable());
579	assertNull(c.call());
580	} catch(Exception ex) {
581	unexpectedException();
582	}
583
584	}
585
586	/**
587	* callable(Runnable, result) returns result when called
588	*/
589	public void testCallable2() {
590	try {
591	Callable c = Executors.callable(new NoOpRunnable(), one);
592	assertEquals(one, c.call());
593	} catch(Exception ex) {
594	unexpectedException();
595	}
596	}
597
598	/**
599	* callable(PrivilegedAction) returns its result when called
600	*/
601	public void testCallable3() {
602	try {
603	Callable c = Executors.callable(new PrivilegedAction() {
604	public Object run() { return one; }});
605	assertEquals(one, c.call());
606	} catch(Exception ex) {
607	unexpectedException();
608	}
609	}
610
611	/**
612	* callable(PrivilegedExceptionAction) returns its result when called
613	*/
614	public void testCallable4() {
615	try {
616	Callable c = Executors.callable(new PrivilegedExceptionAction() {
617	public Object run() { return one; }});
618	assertEquals(one, c.call());
619	} catch(Exception ex) {
620	unexpectedException();
621	}
622	}
623
624
625	/**
626	* callable(null Runnable) throws NPE
627	*/
628	public void testCallableNPE1() {
629	try {
630	Runnable r = null;
631	Callable c = Executors.callable(r);
632	} catch (NullPointerException success) {
633	}
634	}
635
636	/**
637	* callable(null, result) throws NPE
638	*/
639	public void testCallableNPE2() {
640	try {
641	Runnable r = null;
642	Callable c = Executors.callable(r, one);
643	} catch (NullPointerException success) {
644	}
645	}
646
647	/**
648	* callable(null PrivilegedAction) throws NPE
649	*/
650	public void testCallableNPE3() {
651	try {
652	PrivilegedAction r = null;
653	Callable c = Executors.callable(r);
654	} catch (NullPointerException success) {
655	}
656	}
657
658	/**
659	* callable(null PrivilegedExceptionAction) throws NPE
660	*/
661	public void testCallableNPE4() {
662	try {
663	PrivilegedExceptionAction r = null;
664	Callable c = Executors.callable(r);
665	} catch (NullPointerException success) {
666	}
667	}
668
669
670	}