test/tck/ExecutorsTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */


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

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);
    }

    private static final String TEST_STRING = "a test string";

    private static class StringTask implements Callable<String> {
        public String call() { return TEST_STRING; }
    }

    static class DirectExecutor implements Executor {
        public void execute(Runnable r) {
            r.run();
        }
    }

    static class TimedCallable<T> implements Callable<T> {
        private final Executor exec;
        private final Callable<T> func;
        private final long msecs;
        
        TimedCallable(Executor exec, Callable<T> func, long msecs) {
            this.exec = exec;
            this.func = func;
            this.msecs = msecs;
        }
        
        public T call() throws Exception {
            Future<T> ftask = Executors.execute(exec, 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());
        e.shutdown();
    }

    /**
     * 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());
        e.shutdown();
    }

    /**
     * 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());
        e.shutdown();
    }

    /**
     * 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());
        e.shutdown();
    }

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

    /**
     * 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());
        e.shutdown();
    }

    /**
     * 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());
        e.shutdown();
    }

    /**
     * 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) {
        }
    }

    /**
     * execute of runnable runs it to completion 
     */
    public void testExecuteRunnable() {
        try {
            Executor e = new DirectExecutor();
            TrackedShortRunnable task = new TrackedShortRunnable();
            assertFalse(task.done);
            Future<?> future = Executors.execute(e, task);
            future.get();
            assertTrue(task.done);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * invoke of a runnable runs it to completion 
     */
    public void testInvokeRunnable() {
        try {
            Executor e = new DirectExecutor();
            TrackedShortRunnable task = new TrackedShortRunnable();
            assertFalse(task.done);
            Executors.invoke(e, task);
            assertTrue(task.done);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * execute of a callable runs it to completion
     */
    public void testExecuteCallable() {
        try {
            Executor e = new DirectExecutor();
            Future<String> future = Executors.execute(e, new StringTask());
            String result = future.get();
            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }


    /**
     * execute of a privileged action runs it to completion
     */
    public void testExecutePrivilegedAction() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        try {
            Executor e = new DirectExecutor();
            Future future = Executors.execute(e, new PrivilegedAction() {
                    public Object run() {
                        return TEST_STRING;
                    }});

            Object result = future.get();
            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * execute of a privileged exception action runs it to completion
     */
    public void testExecutePrivilegedExceptionAction() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        try {
            Executor e = new DirectExecutor();
            Future future = Executors.execute(e, new PrivilegedExceptionAction() {
                    public Object run() {
                        return TEST_STRING;
                    }});

            Object result = future.get();
            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * execute of a failed privileged exception action reports exception
     */
    public void testExecuteFailedPrivilegedExceptionAction() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        try {
            Executor e = new DirectExecutor();
            Future future = Executors.execute(e, new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        throw new IndexOutOfBoundsException();
                    }});

            Object result = future.get();
            shouldThrow();
        }
        catch (ExecutionException success) {
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * invoke of a collable runs it to completion
     */
    public void testInvokeCallable() {
        try {
            Executor e = new DirectExecutor();
            String result = Executors.invoke(e, new StringTask());

            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * execute with null executor throws NPE
     */
    public void testNullExecuteRunnable() {
        try {
            TrackedShortRunnable task = new TrackedShortRunnable();
            assertFalse(task.done);
            Future<?> future = Executors.execute(null, task);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * execute with a null runnable throws NPE
     */
    public void testExecuteNullRunnable() {
        try {
            Executor e = new DirectExecutor();
            TrackedShortRunnable task = null;
            Future<?> future = Executors.execute(e, task);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * invoke of a null runnable throws NPE
     */
    public void testInvokeNullRunnable() {
        try {
            Executor e = new DirectExecutor();
            TrackedShortRunnable task = null;
            Executors.invoke(e, task);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * execute of a null callable throws NPE
     */
    public void testExecuteNullCallable() {
        try {
            Executor e = new DirectExecutor();
            StringTask t = null;
            Future<String> future = Executors.execute(e, t);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * invoke of a null callable throws NPE
     */
    public void testInvokeNullCallable() {
        try {
            Executor e = new DirectExecutor();
            StringTask t = null;
            String result = Executors.invoke(e, t);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     *  execute(Executor, Runnable) throws RejectedExecutionException
     *  if saturated.
     */
    public void testExecute1() {
        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
        try {
            
            for(int i = 0; i < 5; ++i){
                Executors.execute(p, new MediumRunnable());
            }
            shouldThrow();
        } catch(RejectedExecutionException success){}
        joinPool(p);
    }

    /**
     *  execute(Executor, Callable)throws RejectedExecutionException
     *  if saturated.
     */
    public void testExecute2() {
         ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
        try {
            for(int i = 0; i < 5; ++i) {
                Executors.execute(p, new SmallCallable());
            }
            shouldThrow();
        } catch(RejectedExecutionException e){}
        joinPool(p);
    }


    /**
     *  invoke(Executor, Runnable) throws InterruptedException if
     *  caller interrupted.
     */
    public void testInterruptedInvoke() {
        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        Executors.invoke(p,new Runnable() {
                                public void run() {
                                    try {
                                        Thread.sleep(MEDIUM_DELAY_MS);
                                        shouldThrow();
                                    } catch(InterruptedException e){
                                    }
                                }
                            });
                    } catch(InterruptedException success){
                    } catch(Exception e) {
                        unexpectedException();
                    }
                    
                }
            }); 
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
        } catch(Exception e){
            unexpectedException();
        }
        joinPool(p);
    }

    /**
     *  invoke(Executor, Runnable) throws ExecutionException if
     *  runnable throws exception.
     */
    public void testInvoke3() {
        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            Runnable r = new Runnable() {
                    public void run() {
                        int i = 5/0;
                    }
                };
            
            for(int i =0; i < 5; i++){
                Executors.invoke(p,r);
            }
            
            shouldThrow();
        } catch(ExecutionException success){
        } catch(Exception e){
            unexpectedException();
        }
        joinPool(p);
    }


    /**
     *  invoke(Executor, Callable) throws InterruptedException if
     *  callable throws exception
     */
    public void testInvoke5() {
        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        
        final Callable c = new Callable() {
                public Object call() {
                    try {
                        Executors.invoke(p, new SmallCallable());
                        shouldThrow();
                    } catch(InterruptedException e){}
                    catch(RejectedExecutionException e2){}
                    catch(ExecutionException e3){}
                    return Boolean.TRUE;
                }
            };


        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.call();
                    } catch(Exception e){}
                }
          });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException e){
            unexpectedException();
        }
        
        joinPool(p);
    }

    /**
     *  invoke(Executor, Callable) will throw ExecutionException
     *  if callable throws exception
     */
    public void testInvoke6() {
        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));

        try {
            Callable c = new Callable() {
                    public Object call() {
                        int i = 5/0;
                        return Boolean.TRUE;
                    }
                };
            
            for(int i =0; i < 5; i++){
                Executors.invoke(p,c);
            }
            
            shouldThrow();
        } 
        catch(ExecutionException success){
        } catch(Exception e) {
            unexpectedException();
        }
        joinPool(p);
    }


    /**
     *  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() {
                    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"));
                }
            };
        ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
        
        e.execute(r);
        e.shutdown();
        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 = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
        final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
        final AccessControlContext thisacc = AccessController.getContext();
        Runnable r = new Runnable() {
                public void run() {
                    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()));
                }
            };
        ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
        
        Policy.setPolicy(savedPolicy);
        e.execute(r);
        e.shutdown();
        try {
            Thread.sleep(SHORT_DELAY_MS);
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }

    }

}
Revision:	1.9
Committed:	Tue Dec 9 19:09:24 2003 UTC (20 years, 4 months ago) by tim
Branch:	MAIN
CVS Tags:	JSR166_DEC9_PRE_ES_SUBMIT
Changes since 1.8:	+91 -92 lines
Log Message:	Some tests were still using <V> Future<V> execute(Executor,Runnable,V)
#	Content
1	/*
2	* Written by members of JCP JSR-166 Expert Group and released to the
3	* public domain. Use, modify, and redistribute this code in any way
4	* without acknowledgement. Other contributors include Andrew Wright,
5	* Jeffrey Hayes, Pat Fischer, Mike Judd.
6	*/
7
8
9	import junit.framework.*;
10	import java.util.*;
11	import java.util.concurrent.*;
12	import java.math.BigInteger;
13	import java.security.*;
14
15	public class ExecutorsTest extends JSR166TestCase{
16	public static void main(String[] args) {
17	junit.textui.TestRunner.run (suite());
18	}
19	public static Test suite() {
20	return new TestSuite(ExecutorsTest.class);
21	}
22
23	private static final String TEST_STRING = "a test string";
24
25	private static class StringTask implements Callable<String> {
26	public String call() { return TEST_STRING; }
27	}
28
29	static class DirectExecutor implements Executor {
30	public void execute(Runnable r) {
31	r.run();
32	}
33	}
34
35	static class TimedCallable<T> implements Callable<T> {
36	private final Executor exec;
37	private final Callable<T> func;
38	private final long msecs;
39
40	TimedCallable(Executor exec, Callable<T> func, long msecs) {
41	this.exec = exec;
42	this.func = func;
43	this.msecs = msecs;
44	}
45
46	public T call() throws Exception {
47	Future<T> ftask = Executors.execute(exec, func);
48	try {
49	return ftask.get(msecs, TimeUnit.MILLISECONDS);
50	} finally {
51	ftask.cancel(true);
52	}
53	}
54	}
55
56
57	private static class Fib implements Callable<BigInteger> {
58	private final BigInteger n;
59	Fib(long n) {
60	if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
61	this.n = BigInteger.valueOf(n);
62	}
63	public BigInteger call() {
64	BigInteger f1 = BigInteger.ONE;
65	BigInteger f2 = f1;
66	for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
67	BigInteger t = f1.add(f2);
68	f1 = f2;
69	f2 = t;
70	}
71	return f1;
72	}
73	};
74
75	/**
76	* A newCachedThreadPool can execute runnables
77	*/
78	public void testNewCachedThreadPool1() {
79	ExecutorService e = Executors.newCachedThreadPool();
80	e.execute(new NoOpRunnable());
81	e.execute(new NoOpRunnable());
82	e.execute(new NoOpRunnable());
83	e.shutdown();
84	}
85
86	/**
87	* A newCachedThreadPool with given ThreadFactory can execute runnables
88	*/
89	public void testNewCachedThreadPool2() {
90	ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
91	e.execute(new NoOpRunnable());
92	e.execute(new NoOpRunnable());
93	e.execute(new NoOpRunnable());
94	e.shutdown();
95	}
96
97	/**
98	* A newCachedThreadPool with null ThreadFactory throws NPE
99	*/
100	public void testNewCachedThreadPool3() {
101	try {
102	ExecutorService e = Executors.newCachedThreadPool(null);
103	shouldThrow();
104	}
105	catch(NullPointerException success) {
106	}
107	}
108
109
110	/**
111	* A new SingleThreadExecutor can execute runnables
112	*/
113	public void testNewSingleThreadExecutor1() {
114	ExecutorService e = Executors.newSingleThreadExecutor();
115	e.execute(new NoOpRunnable());
116	e.execute(new NoOpRunnable());
117	e.execute(new NoOpRunnable());
118	e.shutdown();
119	}
120
121	/**
122	* A new SingleThreadExecutor with given ThreadFactory can execute runnables
123	*/
124	public void testNewSingleThreadExecutor2() {
125	ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
126	e.execute(new NoOpRunnable());
127	e.execute(new NoOpRunnable());
128	e.execute(new NoOpRunnable());
129	e.shutdown();
130	}
131
132	/**
133	* A new SingleThreadExecutor with null ThreadFactory throws NPE
134	*/
135	public void testNewSingleThreadExecutor3() {
136	try {
137	ExecutorService e = Executors.newSingleThreadExecutor(null);
138	shouldThrow();
139	}
140	catch(NullPointerException success) {
141	}
142	}
143
144	/**
145	* A new newFixedThreadPool can execute runnables
146	*/
147	public void testNewFixedThreadPool1() {
148	ExecutorService e = Executors.newFixedThreadPool(2);
149	e.execute(new NoOpRunnable());
150	e.execute(new NoOpRunnable());
151	e.execute(new NoOpRunnable());
152	e.shutdown();
153	}
154
155	/**
156	* A new newFixedThreadPool with given ThreadFactory can execute runnables
157	*/
158	public void testNewFixedThreadPool2() {
159	ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
160	e.execute(new NoOpRunnable());
161	e.execute(new NoOpRunnable());
162	e.execute(new NoOpRunnable());
163	e.shutdown();
164	}
165
166	/**
167	* A new newFixedThreadPool with null ThreadFactory throws NPE
168	*/
169	public void testNewFixedThreadPool3() {
170	try {
171	ExecutorService e = Executors.newFixedThreadPool(2, null);
172	shouldThrow();
173	}
174	catch(NullPointerException success) {
175	}
176	}
177
178	/**
179	* A new newFixedThreadPool with 0 threads throws IAE
180	*/
181	public void testNewFixedThreadPool4() {
182	try {
183	ExecutorService e = Executors.newFixedThreadPool(0);
184	shouldThrow();
185	}
186	catch(IllegalArgumentException success) {
187	}
188	}
189
190	/**
191	* execute of runnable runs it to completion
192	*/
193	public void testExecuteRunnable() {
194	try {
195	Executor e = new DirectExecutor();
196	TrackedShortRunnable task = new TrackedShortRunnable();
197	assertFalse(task.done);
198	Future<?> future = Executors.execute(e, task);
199	future.get();
200	assertTrue(task.done);
201	}
202	catch (ExecutionException ex) {
203	unexpectedException();
204	}
205	catch (InterruptedException ex) {
206	unexpectedException();
207	}
208	}
209
210	/**
211	* invoke of a runnable runs it to completion
212	*/
213	public void testInvokeRunnable() {
214	try {
215	Executor e = new DirectExecutor();
216	TrackedShortRunnable task = new TrackedShortRunnable();
217	assertFalse(task.done);
218	Executors.invoke(e, task);
219	assertTrue(task.done);
220	}
221	catch (ExecutionException ex) {
222	unexpectedException();
223	}
224	catch (InterruptedException ex) {
225	unexpectedException();
226	}
227	}
228
229	/**
230	* execute of a callable runs it to completion
231	*/
232	public void testExecuteCallable() {
233	try {
234	Executor e = new DirectExecutor();
235	Future<String> future = Executors.execute(e, new StringTask());
236	String result = future.get();
237	assertSame(TEST_STRING, result);
238	}
239	catch (ExecutionException ex) {
240	unexpectedException();
241	}
242	catch (InterruptedException ex) {
243	unexpectedException();
244	}
245	}
246
247
248	/**
249	* execute of a privileged action runs it to completion
250	*/
251	public void testExecutePrivilegedAction() {
252	Policy savedPolicy = Policy.getPolicy();
253	AdjustablePolicy policy = new AdjustablePolicy();
254	policy.addPermission(new RuntimePermission("getContextClassLoader"));
255	policy.addPermission(new RuntimePermission("setContextClassLoader"));
256	Policy.setPolicy(policy);
257	try {
258	Executor e = new DirectExecutor();
259	Future future = Executors.execute(e, new PrivilegedAction() {
260	public Object run() {
261	return TEST_STRING;
262	}});
263
264	Object result = future.get();
265	assertSame(TEST_STRING, result);
266	}
267	catch (ExecutionException ex) {
268	unexpectedException();
269	}
270	catch (InterruptedException ex) {
271	unexpectedException();
272	}
273	finally {
274	Policy.setPolicy(savedPolicy);
275	}
276	}
277
278	/**
279	* execute of a privileged exception action runs it to completion
280	*/
281	public void testExecutePrivilegedExceptionAction() {
282	Policy savedPolicy = Policy.getPolicy();
283	AdjustablePolicy policy = new AdjustablePolicy();
284	policy.addPermission(new RuntimePermission("getContextClassLoader"));
285	policy.addPermission(new RuntimePermission("setContextClassLoader"));
286	Policy.setPolicy(policy);
287	try {
288	Executor e = new DirectExecutor();
289	Future future = Executors.execute(e, new PrivilegedExceptionAction() {
290	public Object run() {
291	return TEST_STRING;
292	}});
293
294	Object result = future.get();
295	assertSame(TEST_STRING, result);
296	}
297	catch (ExecutionException ex) {
298	unexpectedException();
299	}
300	catch (InterruptedException ex) {
301	unexpectedException();
302	}
303	finally {
304	Policy.setPolicy(savedPolicy);
305	}
306	}
307
308	/**
309	* execute of a failed privileged exception action reports exception
310	*/
311	public void testExecuteFailedPrivilegedExceptionAction() {
312	Policy savedPolicy = Policy.getPolicy();
313	AdjustablePolicy policy = new AdjustablePolicy();
314	policy.addPermission(new RuntimePermission("getContextClassLoader"));
315	policy.addPermission(new RuntimePermission("setContextClassLoader"));
316	Policy.setPolicy(policy);
317	try {
318	Executor e = new DirectExecutor();
319	Future future = Executors.execute(e, new PrivilegedExceptionAction() {
320	public Object run() throws Exception {
321	throw new IndexOutOfBoundsException();
322	}});
323
324	Object result = future.get();
325	shouldThrow();
326	}
327	catch (ExecutionException success) {
328	}
329	catch (InterruptedException ex) {
330	unexpectedException();
331	}
332	finally {
333	Policy.setPolicy(savedPolicy);
334	}
335	}
336
337	/**
338	* invoke of a collable runs it to completion
339	*/
340	public void testInvokeCallable() {
341	try {
342	Executor e = new DirectExecutor();
343	String result = Executors.invoke(e, new StringTask());
344
345	assertSame(TEST_STRING, result);
346	}
347	catch (ExecutionException ex) {
348	unexpectedException();
349	}
350	catch (InterruptedException ex) {
351	unexpectedException();
352	}
353	}
354
355	/**
356	* execute with null executor throws NPE
357	*/
358	public void testNullExecuteRunnable() {
359	try {
360	TrackedShortRunnable task = new TrackedShortRunnable();
361	assertFalse(task.done);
362	Future<?> future = Executors.execute(null, task);
363	shouldThrow();
364	}
365	catch (NullPointerException success) {
366	}
367	catch (Exception ex) {
368	unexpectedException();
369	}
370	}
371
372	/**
373	* execute with a null runnable throws NPE
374	*/
375	public void testExecuteNullRunnable() {
376	try {
377	Executor e = new DirectExecutor();
378	TrackedShortRunnable task = null;
379	Future<?> future = Executors.execute(e, task);
380	shouldThrow();
381	}
382	catch (NullPointerException success) {
383	}
384	catch (Exception ex) {
385	unexpectedException();
386	}
387	}
388
389	/**
390	* invoke of a null runnable throws NPE
391	*/
392	public void testInvokeNullRunnable() {
393	try {
394	Executor e = new DirectExecutor();
395	TrackedShortRunnable task = null;
396	Executors.invoke(e, task);
397	shouldThrow();
398	}
399	catch (NullPointerException success) {
400	}
401	catch (Exception ex) {
402	unexpectedException();
403	}
404	}
405
406	/**
407	* execute of a null callable throws NPE
408	*/
409	public void testExecuteNullCallable() {
410	try {
411	Executor e = new DirectExecutor();
412	StringTask t = null;
413	Future<String> future = Executors.execute(e, t);
414	shouldThrow();
415	}
416	catch (NullPointerException success) {
417	}
418	catch (Exception ex) {
419	unexpectedException();
420	}
421	}
422
423	/**
424	* invoke of a null callable throws NPE
425	*/
426	public void testInvokeNullCallable() {
427	try {
428	Executor e = new DirectExecutor();
429	StringTask t = null;
430	String result = Executors.invoke(e, t);
431	shouldThrow();
432	}
433	catch (NullPointerException success) {
434	}
435	catch (Exception ex) {
436	unexpectedException();
437	}
438	}
439
440	/**
441	* execute(Executor, Runnable) throws RejectedExecutionException
442	* if saturated.
443	*/
444	public void testExecute1() {
445	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
446	try {
447
448	for(int i = 0; i < 5; ++i){
449	Executors.execute(p, new MediumRunnable());
450	}
451	shouldThrow();
452	} catch(RejectedExecutionException success){}
453	joinPool(p);
454	}
455
456	/**
457	* execute(Executor, Callable)throws RejectedExecutionException
458	* if saturated.
459	*/
460	public void testExecute2() {
461	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
462	try {
463	for(int i = 0; i < 5; ++i) {
464	Executors.execute(p, new SmallCallable());
465	}
466	shouldThrow();
467	} catch(RejectedExecutionException e){}
468	joinPool(p);
469	}
470
471
472	/**
473	* invoke(Executor, Runnable) throws InterruptedException if
474	* caller interrupted.
475	*/
476	public void testInterruptedInvoke() {
477	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
478	Thread t = new Thread(new Runnable() {
479	public void run() {
480	try {
481	Executors.invoke(p,new Runnable() {
482	public void run() {
483	try {
484	Thread.sleep(MEDIUM_DELAY_MS);
485	shouldThrow();
486	} catch(InterruptedException e){
487	}
488	}
489	});
490	} catch(InterruptedException success){
491	} catch(Exception e) {
492	unexpectedException();
493	}
494
495	}
496	});
497	try {
498	t.start();
499	Thread.sleep(SHORT_DELAY_MS);
500	t.interrupt();
501	} catch(Exception e){
502	unexpectedException();
503	}
504	joinPool(p);
505	}
506
507	/**
508	* invoke(Executor, Runnable) throws ExecutionException if
509	* runnable throws exception.
510	*/
511	public void testInvoke3() {
512	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
513	try {
514	Runnable r = new Runnable() {
515	public void run() {
516	int i = 5/0;
517	}
518	};
519
520	for(int i =0; i < 5; i++){
521	Executors.invoke(p,r);
522	}
523
524	shouldThrow();
525	} catch(ExecutionException success){
526	} catch(Exception e){
527	unexpectedException();
528	}
529	joinPool(p);
530	}
531
532
533
534	/**
535	* invoke(Executor, Callable) throws InterruptedException if
536	* callable throws exception
537	*/
538	public void testInvoke5() {
539	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
540
541	final Callable c = new Callable() {
542	public Object call() {
543	try {
544	Executors.invoke(p, new SmallCallable());
545	shouldThrow();
546	} catch(InterruptedException e){}
547	catch(RejectedExecutionException e2){}
548	catch(ExecutionException e3){}
549	return Boolean.TRUE;
550	}
551	};
552
553
554
555	Thread t = new Thread(new Runnable() {
556	public void run() {
557	try {
558	c.call();
559	} catch(Exception e){}
560	}
561	});
562	try {
563	t.start();
564	Thread.sleep(SHORT_DELAY_MS);
565	t.interrupt();
566	t.join();
567	} catch(InterruptedException e){
568	unexpectedException();
569	}
570
571	joinPool(p);
572	}
573
574	/**
575	* invoke(Executor, Callable) will throw ExecutionException
576	* if callable throws exception
577	*/
578	public void testInvoke6() {
579	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
580
581	try {
582	Callable c = new Callable() {
583	public Object call() {
584	int i = 5/0;
585	return Boolean.TRUE;
586	}
587	};
588
589	for(int i =0; i < 5; i++){
590	Executors.invoke(p,c);
591	}
592
593	shouldThrow();
594	}
595	catch(ExecutionException success){
596	} catch(Exception e) {
597	unexpectedException();
598	}
599	joinPool(p);
600	}
601
602
603
604	/**
605	* timeouts from execute will time out if they compute too long.
606	*/
607	public void testTimedCallable() {
608	int N = 10000;
609	ExecutorService executor = Executors.newSingleThreadExecutor();
610	List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
611	try {
612	long startTime = System.currentTimeMillis();
613
614	long i = 0;
615	while (tasks.size() < N) {
616	tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
617	i += 10;
618	}
619
620	int iters = 0;
621	BigInteger sum = BigInteger.ZERO;
622	for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
623	try {
624	++iters;
625	sum = sum.add(it.next().call());
626	}
627	catch (TimeoutException success) {
628	assertTrue(iters > 0);
629	return;
630	}
631	catch (Exception e) {
632	unexpectedException();
633	}
634	}
635	// if by chance we didn't ever time out, total time must be small
636	long elapsed = System.currentTimeMillis() - startTime;
637	assertTrue(elapsed < N);
638	}
639	finally {
640	joinPool(executor);
641	}
642	}
643
644
645	/**
646	* ThreadPoolExecutor using defaultThreadFactory has
647	* specified group, priority, daemon status, and name
648	*/
649	public void testDefaultThreadFactory() {
650	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
651	Runnable r = new Runnable() {
652	public void run() {
653	Thread current = Thread.currentThread();
654	threadAssertTrue(!current.isDaemon());
655	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
656	ThreadGroup g = current.getThreadGroup();
657	SecurityManager s = System.getSecurityManager();
658	if (s != null)
659	threadAssertTrue(g == s.getThreadGroup());
660	else
661	threadAssertTrue(g == egroup);
662	String name = current.getName();
663	threadAssertTrue(name.endsWith("thread-1"));
664	}
665	};
666	ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
667
668	e.execute(r);
669	e.shutdown();
670	try {
671	Thread.sleep(SHORT_DELAY_MS);
672	} catch (Exception eX) {
673	unexpectedException();
674	} finally {
675	joinPool(e);
676	}
677	}
678
679	/**
680	* ThreadPoolExecutor using privilegedThreadFactory has
681	* specified group, priority, daemon status, name,
682	* access control context and context class loader
683	*/
684	public void testPrivilegedThreadFactory() {
685	Policy savedPolicy = Policy.getPolicy();
686	AdjustablePolicy policy = new AdjustablePolicy();
687	policy.addPermission(new RuntimePermission("getContextClassLoader"));
688	policy.addPermission(new RuntimePermission("setContextClassLoader"));
689	Policy.setPolicy(policy);
690	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
691	final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
692	final AccessControlContext thisacc = AccessController.getContext();
693	Runnable r = new Runnable() {
694	public void run() {
695	Thread current = Thread.currentThread();
696	threadAssertTrue(!current.isDaemon());
697	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
698	ThreadGroup g = current.getThreadGroup();
699	SecurityManager s = System.getSecurityManager();
700	if (s != null)
701	threadAssertTrue(g == s.getThreadGroup());
702	else
703	threadAssertTrue(g == egroup);
704	String name = current.getName();
705	threadAssertTrue(name.endsWith("thread-1"));
706	threadAssertTrue(thisccl == current.getContextClassLoader());
707	threadAssertTrue(thisacc.equals(AccessController.getContext()));
708	}
709	};
710	ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
711
712	Policy.setPolicy(savedPolicy);
713	e.execute(r);
714	e.shutdown();
715	try {
716	Thread.sleep(SHORT_DELAY_MS);
717	} catch (Exception ex) {
718	unexpectedException();
719	} finally {
720	joinPool(e);
721	}
722
723	}
724
725	}