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

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


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

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

    }

    static class CheckCCL implements Callable<Object> {
        public Object call() {
            AccessControlContext acc = AccessController.getContext();
            acc.checkPermission(new RuntimePermission("getContextClassLoader"));
            return null;
        }
    }


    /**
     * Without class loader permissions, creating
     * privilegedCallableUsingCurrentClassLoader throws ACE
     */
    public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        Policy.setPolicy(policy);
        try {
            Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
            shouldThrow();
        } catch(AccessControlException success) {
        } catch(Exception ex) {
            unexpectedException();
        } 
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * Without class loader permissions, calling
     * privilegedCallableUsingCurrentClassLoader throws ACE
     */
    public void testprivilegedCallableUsingCCLWithPrivs() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        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() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        Policy.setPolicy(policy);
        Callable task = Executors.privilegedCallable(new CheckCCL());
        Policy.setPolicy(savedPolicy);
        try {
            task.call();
            shouldThrow();
        } catch(AccessControlException success) {
        } catch(Exception ex) {
            unexpectedException();
        } finally {
        }
    }

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