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)
#	User	Rev	Content
1	dl	1.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	dl	1.2	import java.math.BigInteger;
13	dl	1.8	import java.security.*;
14	dl	1.1
15	dl	1.3	public class ExecutorsTest extends JSR166TestCase{
16	dl	1.1	public static void main(String[] args) {
17	tim	1.9	junit.textui.TestRunner.run (suite());
18	dl	1.1	}
19			public static Test suite() {
20	tim	1.9	return new TestSuite(ExecutorsTest.class);
21	dl	1.1	}
22
23	dl	1.4	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	dl	1.5	/**
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	dl	1.6	ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
91	dl	1.5	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	dl	1.6	ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
126	dl	1.5	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	dl	1.6	ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
160	dl	1.5	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	dl	1.7	public void testExecuteRunnable() {
194	dl	1.5	try {
195			Executor e = new DirectExecutor();
196	dl	1.7	TrackedShortRunnable task = new TrackedShortRunnable();
197	dl	1.6	assertFalse(task.done);
198	tim	1.9	Future<?> future = Executors.execute(e, task);
199			future.get();
200	dl	1.6	assertTrue(task.done);
201	dl	1.5	}
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	dl	1.7	public void testInvokeRunnable() {
214	dl	1.5	try {
215			Executor e = new DirectExecutor();
216	dl	1.7	TrackedShortRunnable task = new TrackedShortRunnable();
217	dl	1.6	assertFalse(task.done);
218	dl	1.5	Executors.invoke(e, task);
219	dl	1.6	assertTrue(task.done);
220	dl	1.5	}
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	dl	1.7	public void testExecuteCallable() {
233	dl	1.5	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	dl	1.8
248			/**
249			* execute of a privileged action runs it to completion
250			*/
251			public void testExecutePrivilegedAction() {
252	tim	1.9	Policy savedPolicy = Policy.getPolicy();
253	dl	1.8	AdjustablePolicy policy = new AdjustablePolicy();
254			policy.addPermission(new RuntimePermission("getContextClassLoader"));
255			policy.addPermission(new RuntimePermission("setContextClassLoader"));
256	tim	1.9	Policy.setPolicy(policy);
257	dl	1.8	try {
258			Executor e = new DirectExecutor();
259			Future future = Executors.execute(e, new PrivilegedAction() {
260	tim	1.9	public Object run() {
261			return TEST_STRING;
262			}});
263	dl	1.8
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	tim	1.9	finally {
274			Policy.setPolicy(savedPolicy);
275			}
276	dl	1.8	}
277
278			/**
279			* execute of a privileged exception action runs it to completion
280			*/
281			public void testExecutePrivilegedExceptionAction() {
282	tim	1.9	Policy savedPolicy = Policy.getPolicy();
283	dl	1.8	AdjustablePolicy policy = new AdjustablePolicy();
284			policy.addPermission(new RuntimePermission("getContextClassLoader"));
285			policy.addPermission(new RuntimePermission("setContextClassLoader"));
286	tim	1.9	Policy.setPolicy(policy);
287	dl	1.8	try {
288			Executor e = new DirectExecutor();
289			Future future = Executors.execute(e, new PrivilegedExceptionAction() {
290	tim	1.9	public Object run() {
291			return TEST_STRING;
292			}});
293	dl	1.8
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	tim	1.9	finally {
304			Policy.setPolicy(savedPolicy);
305			}
306	dl	1.8	}
307
308			/**
309			* execute of a failed privileged exception action reports exception
310			*/
311			public void testExecuteFailedPrivilegedExceptionAction() {
312	tim	1.9	Policy savedPolicy = Policy.getPolicy();
313	dl	1.8	AdjustablePolicy policy = new AdjustablePolicy();
314			policy.addPermission(new RuntimePermission("getContextClassLoader"));
315			policy.addPermission(new RuntimePermission("setContextClassLoader"));
316	tim	1.9	Policy.setPolicy(policy);
317	dl	1.8	try {
318			Executor e = new DirectExecutor();
319			Future future = Executors.execute(e, new PrivilegedExceptionAction() {
320	tim	1.9	public Object run() throws Exception {
321			throw new IndexOutOfBoundsException();
322			}});
323	dl	1.8
324			Object result = future.get();
325			shouldThrow();
326			}
327			catch (ExecutionException success) {
328			}
329			catch (InterruptedException ex) {
330			unexpectedException();
331			}
332	tim	1.9	finally {
333			Policy.setPolicy(savedPolicy);
334			}
335	dl	1.8	}
336
337	dl	1.5	/**
338			* invoke of a collable runs it to completion
339			*/
340	dl	1.7	public void testInvokeCallable() {
341	dl	1.5	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	dl	1.4
355	dl	1.5	/**
356			* execute with null executor throws NPE
357			*/
358	dl	1.7	public void testNullExecuteRunnable() {
359	dl	1.5	try {
360	dl	1.7	TrackedShortRunnable task = new TrackedShortRunnable();
361	dl	1.6	assertFalse(task.done);
362	tim	1.9	Future<?> future = Executors.execute(null, task);
363	dl	1.5	shouldThrow();
364			}
365			catch (NullPointerException success) {
366			}
367			catch (Exception ex) {
368			unexpectedException();
369			}
370			}
371	dl	1.4
372	dl	1.1	/**
373	dl	1.5	* execute with a null runnable throws NPE
374			*/
375			public void testExecuteNullRunnable() {
376			try {
377			Executor e = new DirectExecutor();
378	dl	1.7	TrackedShortRunnable task = null;
379	tim	1.9	Future<?> future = Executors.execute(e, task);
380	dl	1.5	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	dl	1.7	public void testInvokeNullRunnable() {
393	dl	1.5	try {
394			Executor e = new DirectExecutor();
395	dl	1.7	TrackedShortRunnable task = null;
396	dl	1.5	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	dl	1.7	public void testExecuteNullCallable() {
410	dl	1.5	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	dl	1.7	public void testInvokeNullCallable() {
427	dl	1.5	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	dl	1.1	*/
444	dl	1.4	public void testExecute1() {
445	dl	1.3	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
446	dl	1.4	try {
447	dl	1.1
448			for(int i = 0; i < 5; ++i){
449	tim	1.9	Executors.execute(p, new MediumRunnable());
450	dl	1.1	}
451	dl	1.4	shouldThrow();
452	dl	1.1	} catch(RejectedExecutionException success){}
453	dl	1.3	joinPool(p);
454	dl	1.1	}
455
456			/**
457	dl	1.5	* execute(Executor, Callable)throws RejectedExecutionException
458			* if saturated.
459	dl	1.1	*/
460	dl	1.4	public void testExecute2() {
461	dl	1.3	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
462	dl	1.4	try {
463	dl	1.1	for(int i = 0; i < 5; ++i) {
464	dl	1.3	Executors.execute(p, new SmallCallable());
465	dl	1.1	}
466	dl	1.4	shouldThrow();
467			} catch(RejectedExecutionException e){}
468	dl	1.3	joinPool(p);
469	dl	1.1	}
470
471
472			/**
473	dl	1.5	* invoke(Executor, Runnable) throws InterruptedException if
474			* caller interrupted.
475	dl	1.1	*/
476	dl	1.5	public void testInterruptedInvoke() {
477	dl	1.3	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
478	dl	1.1	Thread t = new Thread(new Runnable() {
479	dl	1.4	public void run() {
480			try {
481			Executors.invoke(p,new Runnable() {
482			public void run() {
483			try {
484	dl	1.1	Thread.sleep(MEDIUM_DELAY_MS);
485	dl	1.4	shouldThrow();
486			} catch(InterruptedException e){
487	dl	1.1	}
488			}
489			});
490			} catch(InterruptedException success){
491			} catch(Exception e) {
492	dl	1.4	unexpectedException();
493	dl	1.1	}
494
495			}
496			});
497	dl	1.4	try {
498	dl	1.1	t.start();
499			Thread.sleep(SHORT_DELAY_MS);
500			t.interrupt();
501	dl	1.4	} catch(Exception e){
502			unexpectedException();
503	dl	1.1	}
504	dl	1.3	joinPool(p);
505	dl	1.1	}
506
507			/**
508	dl	1.5	* invoke(Executor, Runnable) throws ExecutionException if
509			* runnable throws exception.
510	dl	1.1	*/
511	dl	1.4	public void testInvoke3() {
512	dl	1.3	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
513	dl	1.4	try {
514			Runnable r = new Runnable() {
515			public void run() {
516	dl	1.1	int i = 5/0;
517			}
518			};
519
520			for(int i =0; i < 5; i++){
521			Executors.invoke(p,r);
522			}
523
524	dl	1.4	shouldThrow();
525	dl	1.1	} catch(ExecutionException success){
526			} catch(Exception e){
527	dl	1.4	unexpectedException();
528	dl	1.1	}
529	dl	1.3	joinPool(p);
530	dl	1.1	}
531
532
533
534			/**
535	dl	1.5	* invoke(Executor, Callable) throws InterruptedException if
536			* callable throws exception
537	dl	1.1	*/
538	dl	1.4	public void testInvoke5() {
539	dl	1.3	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
540	dl	1.1
541	dl	1.4	final Callable c = new Callable() {
542			public Object call() {
543			try {
544	dl	1.3	Executors.invoke(p, new SmallCallable());
545	dl	1.4	shouldThrow();
546			} catch(InterruptedException e){}
547	dl	1.1	catch(RejectedExecutionException e2){}
548			catch(ExecutionException e3){}
549			return Boolean.TRUE;
550			}
551			};
552
553
554
555	dl	1.4	Thread t = new Thread(new Runnable() {
556			public void run() {
557			try {
558	dl	1.1	c.call();
559	dl	1.4	} catch(Exception e){}
560	dl	1.1	}
561			});
562	dl	1.4	try {
563	dl	1.1	t.start();
564			Thread.sleep(SHORT_DELAY_MS);
565			t.interrupt();
566			t.join();
567	dl	1.4	} catch(InterruptedException e){
568			unexpectedException();
569	dl	1.1	}
570
571	dl	1.3	joinPool(p);
572	dl	1.1	}
573
574			/**
575	dl	1.5	* invoke(Executor, Callable) will throw ExecutionException
576			* if callable throws exception
577	dl	1.1	*/
578	dl	1.4	public void testInvoke6() {
579	dl	1.3	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
580	dl	1.1
581	dl	1.4	try {
582			Callable c = new Callable() {
583			public Object call() {
584	dl	1.1	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	dl	1.4	shouldThrow();
594	dl	1.5	}
595			catch(ExecutionException success){
596			} catch(Exception e) {
597	dl	1.4	unexpectedException();
598	dl	1.1	}
599	dl	1.5	joinPool(p);
600	dl	1.1	}
601
602
603	dl	1.2
604			/**
605	dl	1.4	* timeouts from execute will time out if they compute too long.
606	dl	1.2	*/
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	dl	1.4	unexpectedException();
633	dl	1.2	}
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	dl	1.3	joinPool(executor);
641	dl	1.2	}
642			}
643
644
645	dl	1.8	/**
646			* ThreadPoolExecutor using defaultThreadFactory has
647			* specified group, priority, daemon status, and name
648			*/
649			public void testDefaultThreadFactory() {
650	tim	1.9	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	dl	1.8	}
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	tim	1.9	Policy savedPolicy = Policy.getPolicy();
686	dl	1.8	AdjustablePolicy policy = new AdjustablePolicy();
687			policy.addPermission(new RuntimePermission("getContextClassLoader"));
688			policy.addPermission(new RuntimePermission("setContextClassLoader"));
689	tim	1.9	Policy.setPolicy(policy);
690			final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
691			final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
692	dl	1.8	final AccessControlContext thisacc = AccessController.getContext();
693	tim	1.9	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	dl	1.1
723	dl	1.8	}
724	dl	1.1
725			}