test/tck/AbstractExecutorServiceTest.java

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


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

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

    /**
     * A no-frills implementation of AbstractExecutorService, designed
     * to test the submit methods only.
     */
    static class DirectExecutorService extends AbstractExecutorService {
        public void execute(Runnable r) { r.run(); }
        public void shutdown() { shutdown = true; }
        public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
        public boolean isShutdown() { return shutdown; }
        public boolean isTerminated() { return isShutdown(); }
        public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
        private volatile boolean shutdown = false;
    }

    /**
     * execute(runnable) runs it to completion
     */
    public void testExecuteRunnable() throws Exception {
        ExecutorService e = new DirectExecutorService();
        TrackedShortRunnable task = new TrackedShortRunnable();
        assertFalse(task.done);
        Future<?> future = e.submit(task);
        future.get();
        assertTrue(task.done);
    }


    /**
     * Completed submit(callable) returns result
     */
    public void testSubmitCallable() throws Exception {
        ExecutorService e = new DirectExecutorService();
        Future<String> future = e.submit(new StringTask());
        String result = future.get();
        assertSame(TEST_STRING, result);
    }

    /**
     * Completed submit(runnable) returns successfully
     */
    public void testSubmitRunnable() throws Exception {
        ExecutorService e = new DirectExecutorService();
        Future<?> future = e.submit(new NoOpRunnable());
        future.get();
        assertTrue(future.isDone());
    }

    /**
     * Completed submit(runnable, result) returns result
     */
    public void testSubmitRunnable2() throws Exception {
        ExecutorService e = new DirectExecutorService();
        Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
        String result = future.get();
        assertSame(TEST_STRING, result);
    }


    /**
     * A submitted privileged action to completion
     */
    public void testSubmitPrivilegedAction() throws Exception {
        Policy savedPolicy = null;
        try {
            savedPolicy = Policy.getPolicy();
            AdjustablePolicy policy = new AdjustablePolicy();
            policy.addPermission(new RuntimePermission("getContextClassLoader"));
            policy.addPermission(new RuntimePermission("setContextClassLoader"));
            Policy.setPolicy(policy);
        } catch (AccessControlException ok) {
            return;
        }
        try {
            ExecutorService e = new DirectExecutorService();
            Future future = e.submit(Executors.callable(new PrivilegedAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

            Object result = future.get();
            assertSame(TEST_STRING, result);
        }
        finally {
            try {
                Policy.setPolicy(savedPolicy);
            } catch (AccessControlException ok) {
                return;
            }
        }
    }

    /**
     * A submitted a privileged exception action runs to completion
     */
    public void testSubmitPrivilegedExceptionAction() throws Exception {
        Policy savedPolicy = null;
        try {
            savedPolicy = Policy.getPolicy();
            AdjustablePolicy policy = new AdjustablePolicy();
            policy.addPermission(new RuntimePermission("getContextClassLoader"));
            policy.addPermission(new RuntimePermission("setContextClassLoader"));
            Policy.setPolicy(policy);
        } catch (AccessControlException ok) {
            return;
        }

        try {
            ExecutorService e = new DirectExecutorService();
            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

            Object result = future.get();
            assertSame(TEST_STRING, result);
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * A submitted failed privileged exception action reports exception
     */
    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
        Policy savedPolicy = null;
        try {
            savedPolicy = Policy.getPolicy();
            AdjustablePolicy policy = new AdjustablePolicy();
            policy.addPermission(new RuntimePermission("getContextClassLoader"));
            policy.addPermission(new RuntimePermission("setContextClassLoader"));
            Policy.setPolicy(policy);
        } catch (AccessControlException ok) {
            return;
        }

        try {
            ExecutorService e = new DirectExecutorService();
            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        throw new IndexOutOfBoundsException();
                    }}));

            future.get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * execute(null runnable) throws NPE
     */
    public void testExecuteNullRunnable() {
        try {
            ExecutorService e = new DirectExecutorService();
            e.submit((Runnable) null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }


    /**
     * submit(null callable) throws NPE
     */
    public void testSubmitNullCallable() {
        try {
            ExecutorService e = new DirectExecutorService();
            e.submit((Callable) null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * submit(runnable) throws RejectedExecutionException if
     * executor is saturated.
     */
    public void testExecute1() {
        ThreadPoolExecutor p =
            new ThreadPoolExecutor(1, 1,
                                   60, TimeUnit.SECONDS,
                                   new ArrayBlockingQueue<Runnable>(1));
        try {
            for (int i = 0; i < 2; ++i)
                p.submit(new MediumRunnable());
            for (int i = 0; i < 2; ++i) {
                try {
                    p.submit(new MediumRunnable());
                    shouldThrow();
                } catch (RejectedExecutionException success) {}
            }
        } finally {
            joinPool(p);
        }
    }

    /**
     * submit(callable) throws RejectedExecutionException
     * if executor is saturated.
     */
    public void testExecute2() {
        ThreadPoolExecutor p =
            new ThreadPoolExecutor(1, 1,
                                   60, TimeUnit.SECONDS,
                                   new ArrayBlockingQueue<Runnable>(1));
        try {
            for (int i = 0; i < 2; ++i)
                p.submit(new MediumRunnable());
            for (int i = 0; i < 2; ++i) {
                try {
                    p.submit(new SmallCallable());
                    shouldThrow();
                } catch (RejectedExecutionException success) {}
            }
        } finally {
            joinPool(p);
        }
    }


    /**
     *  Blocking on submit(callable) throws InterruptedException if
     *  caller interrupted.
     */
    public void testInterruptedSubmit() throws InterruptedException {
        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                p.submit(new CheckedCallable<Object>() {
                             public Object realCall()
                                 throws InterruptedException {
                                 Thread.sleep(SMALL_DELAY_MS);
                                 return null;
                             }}).get();
            }});

        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        joinPool(p);
    }

    /**
     *  get of submitted callable throws InterruptedException if callable
     *  interrupted
     */
    public void testSubmitIE() throws InterruptedException {
        final ThreadPoolExecutor p =
            new ThreadPoolExecutor(1, 1,
                                   60, TimeUnit.SECONDS,
                                   new ArrayBlockingQueue<Runnable>(10));

        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                p.submit(new SmallCallable()).get();
            }});

        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        t.join();
        joinPool(p);
    }

    /**
     *  get of submit(callable) throws ExecutionException if callable
     *  throws exception
     */
    public void testSubmitEE() throws InterruptedException {
        ThreadPoolExecutor p =
            new ThreadPoolExecutor(1, 1,
                                   60, TimeUnit.SECONDS,
                                   new ArrayBlockingQueue<Runnable>(10));

        Callable c = new Callable() {
            public Object call() { return 5/0; }};

        try {
            p.submit(c).get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof ArithmeticException);
        }
        joinPool(p);
    }

    /**
     * invokeAny(null) throws NPE
     */
    public void testInvokeAny1()
        throws InterruptedException, ExecutionException {
        ExecutorService e = new DirectExecutorService();
        try {
            e.invokeAny(null);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAny(empty collection) throws IAE
     */
    public void testInvokeAny2()
        throws InterruptedException, ExecutionException {
        ExecutorService e = new DirectExecutorService();
        try {
            e.invokeAny(new ArrayList<Callable<String>>());
            shouldThrow();
        } catch (IllegalArgumentException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAny(c) throws NPE if c has null elements
     */
    public void testInvokeAny3() throws Exception {
        final CountDownLatch latch = new CountDownLatch(1);
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<Integer>> l
                = new ArrayList<Callable<Integer>>();
            l.add(new Callable<Integer>() {
                      public Integer call() { return 5/0; }});
            l.add(null);
            e.invokeAny(l);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            latch.countDown();
            joinPool(e);
        }
    }

    /**
     * invokeAny(c) throws ExecutionException if no task in c completes
     */
    public void testInvokeAny4() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            e.invokeAny(l);
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof NullPointerException);
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAny(c) returns result of some task in c if at least one completes
     */
    public void testInvokeAny5() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            String result = e.invokeAny(l);
            assertSame(TEST_STRING, result);
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAll(null) throws NPE
     */
    public void testInvokeAll1() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            e.invokeAll(null);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAll(empty collection) returns empty collection
     */
    public void testInvokeAll2() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
            assertTrue(r.isEmpty());
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAll(c) throws NPE if c has null elements
     */
    public void testInvokeAll3() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(null);
            e.invokeAll(l);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * get of returned element of invokeAll(c) throws exception on failed task
     */
    public void testInvokeAll4() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            List<Future<String>> result = e.invokeAll(l);
            assertEquals(1, result.size());
            for (Future<String> future : result) {
                try {
                    future.get();
                    shouldThrow();
                } catch (ExecutionException success) {
                    Throwable cause = success.getCause();
                    assertTrue(cause instanceof NullPointerException);
                }
            }
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAll(c) returns results of all completed tasks in c
     */
    public void testInvokeAll5() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            List<Future<String>> result = e.invokeAll(l);
            assertEquals(2, result.size());
            for (Future<String> future : result)
                assertSame(TEST_STRING, future.get());
        } finally {
            joinPool(e);
        }
    }


    /**
     * timed invokeAny(null) throws NPE
     */
    public void testTimedInvokeAny1() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAny(null time unit) throws NPE
     */
    public void testTimedInvokeAnyNullTimeUnit() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            e.invokeAny(l, MEDIUM_DELAY_MS, null);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAny(empty collection) throws IAE
     */
    public void testTimedInvokeAny2() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (IllegalArgumentException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAny(c) throws NPE if c has null elements
     */
    public void testTimedInvokeAny3() throws Exception {
        final CountDownLatch latch = new CountDownLatch(1);
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<Integer>> l
                = new ArrayList<Callable<Integer>>();
            l.add(new Callable<Integer>() {
                      public Integer call() { return 5/0; }});
            l.add(null);
            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            latch.countDown();
            joinPool(e);
        }
    }

    /**
     * timed invokeAny(c) throws ExecutionException if no task completes
     */
    public void testTimedInvokeAny4() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof NullPointerException);
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAny(c) returns result of some task in c
     */
    public void testTimedInvokeAny5() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
            assertSame(TEST_STRING, result);
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll(null) throws NPE
     */
    public void testTimedInvokeAll1() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll(null time unit) throws NPE
     */
    public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            e.invokeAll(l, MEDIUM_DELAY_MS, null);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll(empty collection) returns empty collection
     */
    public void testTimedInvokeAll2() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
            assertTrue(r.isEmpty());
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll(c) throws NPE if c has null elements
     */
    public void testTimedInvokeAll3() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(null);
            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * get of returned element of invokeAll(c) throws exception on failed task
     */
    public void testTimedInvokeAll4() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
            assertEquals(1, result.size());
            for (Future<String> future : result) {
                try {
                    future.get();
                    shouldThrow();
                } catch (ExecutionException success) {
                    assertTrue(success.getCause() instanceof NullPointerException);
                }
            }
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll(c) returns results of all completed tasks in c
     */
    public void testTimedInvokeAll5() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
            assertEquals(2, result.size());
            for (Future<String> future : result)
                assertSame(TEST_STRING, future.get());
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll cancels tasks not completed by timeout
     */
    public void testTimedInvokeAll6() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
            l.add(new StringTask());
            List<Future<String>> result = e.invokeAll(l, SMALL_DELAY_MS, MILLISECONDS);
            assertEquals(3, result.size());
            Iterator<Future<String>> it = result.iterator();
            Future<String> f1 = it.next();
            Future<String> f2 = it.next();
            Future<String> f3 = it.next();
            assertTrue(f1.isDone());
            assertFalse(f1.isCancelled());
            assertTrue(f2.isDone());
            assertTrue(f3.isDone());
            assertTrue(f3.isCancelled());
        } finally {
            joinPool(e);
        }
    }

}
Revision:	1.21
Committed:	Sat Nov 21 10:25:05 2009 UTC (14 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.20:	+1 -0 lines
Log Message:	improve exception handling
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/licenses/publicdomain
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9
10	import junit.framework.*;
11	import java.util.*;
12	import java.util.concurrent.*;
13	import static java.util.concurrent.TimeUnit.MILLISECONDS;
14	import java.math.BigInteger;
15	import java.security.*;
16
17	public class AbstractExecutorServiceTest extends JSR166TestCase {
18	public static void main(String[] args) {
19	junit.textui.TestRunner.run (suite());
20	}
21	public static Test suite() {
22	return new TestSuite(AbstractExecutorServiceTest.class);
23	}
24
25	/**
26	* A no-frills implementation of AbstractExecutorService, designed
27	* to test the submit methods only.
28	*/
29	static class DirectExecutorService extends AbstractExecutorService {
30	public void execute(Runnable r) { r.run(); }
31	public void shutdown() { shutdown = true; }
32	public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
33	public boolean isShutdown() { return shutdown; }
34	public boolean isTerminated() { return isShutdown(); }
35	public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
36	private volatile boolean shutdown = false;
37	}
38
39	/**
40	* execute(runnable) runs it to completion
41	*/
42	public void testExecuteRunnable() throws Exception {
43	ExecutorService e = new DirectExecutorService();
44	TrackedShortRunnable task = new TrackedShortRunnable();
45	assertFalse(task.done);
46	Future<?> future = e.submit(task);
47	future.get();
48	assertTrue(task.done);
49	}
50
51
52	/**
53	* Completed submit(callable) returns result
54	*/
55	public void testSubmitCallable() throws Exception {
56	ExecutorService e = new DirectExecutorService();
57	Future<String> future = e.submit(new StringTask());
58	String result = future.get();
59	assertSame(TEST_STRING, result);
60	}
61
62	/**
63	* Completed submit(runnable) returns successfully
64	*/
65	public void testSubmitRunnable() throws Exception {
66	ExecutorService e = new DirectExecutorService();
67	Future<?> future = e.submit(new NoOpRunnable());
68	future.get();
69	assertTrue(future.isDone());
70	}
71
72	/**
73	* Completed submit(runnable, result) returns result
74	*/
75	public void testSubmitRunnable2() throws Exception {
76	ExecutorService e = new DirectExecutorService();
77	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
78	String result = future.get();
79	assertSame(TEST_STRING, result);
80	}
81
82
83	/**
84	* A submitted privileged action to completion
85	*/
86	public void testSubmitPrivilegedAction() throws Exception {
87	Policy savedPolicy = null;
88	try {
89	savedPolicy = Policy.getPolicy();
90	AdjustablePolicy policy = new AdjustablePolicy();
91	policy.addPermission(new RuntimePermission("getContextClassLoader"));
92	policy.addPermission(new RuntimePermission("setContextClassLoader"));
93	Policy.setPolicy(policy);
94	} catch (AccessControlException ok) {
95	return;
96	}
97	try {
98	ExecutorService e = new DirectExecutorService();
99	Future future = e.submit(Executors.callable(new PrivilegedAction() {
100	public Object run() {
101	return TEST_STRING;
102	}}));
103
104	Object result = future.get();
105	assertSame(TEST_STRING, result);
106	}
107	finally {
108	try {
109	Policy.setPolicy(savedPolicy);
110	} catch (AccessControlException ok) {
111	return;
112	}
113	}
114	}
115
116	/**
117	* A submitted a privileged exception action runs to completion
118	*/
119	public void testSubmitPrivilegedExceptionAction() throws Exception {
120	Policy savedPolicy = null;
121	try {
122	savedPolicy = Policy.getPolicy();
123	AdjustablePolicy policy = new AdjustablePolicy();
124	policy.addPermission(new RuntimePermission("getContextClassLoader"));
125	policy.addPermission(new RuntimePermission("setContextClassLoader"));
126	Policy.setPolicy(policy);
127	} catch (AccessControlException ok) {
128	return;
129	}
130
131	try {
132	ExecutorService e = new DirectExecutorService();
133	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
134	public Object run() {
135	return TEST_STRING;
136	}}));
137
138	Object result = future.get();
139	assertSame(TEST_STRING, result);
140	}
141	finally {
142	Policy.setPolicy(savedPolicy);
143	}
144	}
145
146	/**
147	* A submitted failed privileged exception action reports exception
148	*/
149	public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
150	Policy savedPolicy = null;
151	try {
152	savedPolicy = Policy.getPolicy();
153	AdjustablePolicy policy = new AdjustablePolicy();
154	policy.addPermission(new RuntimePermission("getContextClassLoader"));
155	policy.addPermission(new RuntimePermission("setContextClassLoader"));
156	Policy.setPolicy(policy);
157	} catch (AccessControlException ok) {
158	return;
159	}
160
161	try {
162	ExecutorService e = new DirectExecutorService();
163	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
164	public Object run() throws Exception {
165	throw new IndexOutOfBoundsException();
166	}}));
167
168	future.get();
169	shouldThrow();
170	} catch (ExecutionException success) {
171	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
172	}
173	finally {
174	Policy.setPolicy(savedPolicy);
175	}
176	}
177
178	/**
179	* execute(null runnable) throws NPE
180	*/
181	public void testExecuteNullRunnable() {
182	try {
183	ExecutorService e = new DirectExecutorService();
184	e.submit((Runnable) null);
185	shouldThrow();
186	} catch (NullPointerException success) {}
187	}
188
189
190	/**
191	* submit(null callable) throws NPE
192	*/
193	public void testSubmitNullCallable() {
194	try {
195	ExecutorService e = new DirectExecutorService();
196	e.submit((Callable) null);
197	shouldThrow();
198	} catch (NullPointerException success) {}
199	}
200
201	/**
202	* submit(runnable) throws RejectedExecutionException if
203	* executor is saturated.
204	*/
205	public void testExecute1() {
206	ThreadPoolExecutor p =
207	new ThreadPoolExecutor(1, 1,
208	60, TimeUnit.SECONDS,
209	new ArrayBlockingQueue<Runnable>(1));
210	try {
211	for (int i = 0; i < 2; ++i)
212	p.submit(new MediumRunnable());
213	for (int i = 0; i < 2; ++i) {
214	try {
215	p.submit(new MediumRunnable());
216	shouldThrow();
217	} catch (RejectedExecutionException success) {}
218	}
219	} finally {
220	joinPool(p);
221	}
222	}
223
224	/**
225	* submit(callable) throws RejectedExecutionException
226	* if executor is saturated.
227	*/
228	public void testExecute2() {
229	ThreadPoolExecutor p =
230	new ThreadPoolExecutor(1, 1,
231	60, TimeUnit.SECONDS,
232	new ArrayBlockingQueue<Runnable>(1));
233	try {
234	for (int i = 0; i < 2; ++i)
235	p.submit(new MediumRunnable());
236	for (int i = 0; i < 2; ++i) {
237	try {
238	p.submit(new SmallCallable());
239	shouldThrow();
240	} catch (RejectedExecutionException success) {}
241	}
242	} finally {
243	joinPool(p);
244	}
245	}
246
247
248	/**
249	* Blocking on submit(callable) throws InterruptedException if
250	* caller interrupted.
251	*/
252	public void testInterruptedSubmit() throws InterruptedException {
253	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
254	Thread t = new Thread(new CheckedInterruptedRunnable() {
255	public void realRun() throws Exception {
256	p.submit(new CheckedCallable<Object>() {
257	public Object realCall()
258	throws InterruptedException {
259	Thread.sleep(SMALL_DELAY_MS);
260	return null;
261	}}).get();
262	}});
263
264	t.start();
265	Thread.sleep(SHORT_DELAY_MS);
266	t.interrupt();
267	joinPool(p);
268	}
269
270	/**
271	* get of submitted callable throws InterruptedException if callable
272	* interrupted
273	*/
274	public void testSubmitIE() throws InterruptedException {
275	final ThreadPoolExecutor p =
276	new ThreadPoolExecutor(1, 1,
277	60, TimeUnit.SECONDS,
278	new ArrayBlockingQueue<Runnable>(10));
279
280	Thread t = new Thread(new CheckedInterruptedRunnable() {
281	public void realRun() throws Exception {
282	p.submit(new SmallCallable()).get();
283	}});
284
285	t.start();
286	Thread.sleep(SHORT_DELAY_MS);
287	t.interrupt();
288	t.join();
289	joinPool(p);
290	}
291
292	/**
293	* get of submit(callable) throws ExecutionException if callable
294	* throws exception
295	*/
296	public void testSubmitEE() throws InterruptedException {
297	ThreadPoolExecutor p =
298	new ThreadPoolExecutor(1, 1,
299	60, TimeUnit.SECONDS,
300	new ArrayBlockingQueue<Runnable>(10));
301
302	Callable c = new Callable() {
303	public Object call() { return 5/0; }};
304
305	try {
306	p.submit(c).get();
307	shouldThrow();
308	} catch (ExecutionException success) {
309	assertTrue(success.getCause() instanceof ArithmeticException);
310	}
311	joinPool(p);
312	}
313
314	/**
315	* invokeAny(null) throws NPE
316	*/
317	public void testInvokeAny1()
318	throws InterruptedException, ExecutionException {
319	ExecutorService e = new DirectExecutorService();
320	try {
321	e.invokeAny(null);
322	shouldThrow();
323	} catch (NullPointerException success) {
324	} finally {
325	joinPool(e);
326	}
327	}
328
329	/**
330	* invokeAny(empty collection) throws IAE
331	*/
332	public void testInvokeAny2()
333	throws InterruptedException, ExecutionException {
334	ExecutorService e = new DirectExecutorService();
335	try {
336	e.invokeAny(new ArrayList<Callable<String>>());
337	shouldThrow();
338	} catch (IllegalArgumentException success) {
339	} finally {
340	joinPool(e);
341	}
342	}
343
344	/**
345	* invokeAny(c) throws NPE if c has null elements
346	*/
347	public void testInvokeAny3() throws Exception {
348	final CountDownLatch latch = new CountDownLatch(1);
349	ExecutorService e = new DirectExecutorService();
350	try {
351	ArrayList<Callable<Integer>> l
352	= new ArrayList<Callable<Integer>>();
353	l.add(new Callable<Integer>() {
354	public Integer call() { return 5/0; }});
355	l.add(null);
356	e.invokeAny(l);
357	shouldThrow();
358	} catch (NullPointerException success) {
359	} finally {
360	latch.countDown();
361	joinPool(e);
362	}
363	}
364
365	/**
366	* invokeAny(c) throws ExecutionException if no task in c completes
367	*/
368	public void testInvokeAny4() throws InterruptedException {
369	ExecutorService e = new DirectExecutorService();
370	try {
371	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
372	l.add(new NPETask());
373	e.invokeAny(l);
374	shouldThrow();
375	} catch (ExecutionException success) {
376	assertTrue(success.getCause() instanceof NullPointerException);
377	} finally {
378	joinPool(e);
379	}
380	}
381
382	/**
383	* invokeAny(c) returns result of some task in c if at least one completes
384	*/
385	public void testInvokeAny5() throws Exception {
386	ExecutorService e = new DirectExecutorService();
387	try {
388	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
389	l.add(new StringTask());
390	l.add(new StringTask());
391	String result = e.invokeAny(l);
392	assertSame(TEST_STRING, result);
393	} finally {
394	joinPool(e);
395	}
396	}
397
398	/**
399	* invokeAll(null) throws NPE
400	*/
401	public void testInvokeAll1() throws InterruptedException {
402	ExecutorService e = new DirectExecutorService();
403	try {
404	e.invokeAll(null);
405	shouldThrow();
406	} catch (NullPointerException success) {
407	} finally {
408	joinPool(e);
409	}
410	}
411
412	/**
413	* invokeAll(empty collection) returns empty collection
414	*/
415	public void testInvokeAll2() throws InterruptedException {
416	ExecutorService e = new DirectExecutorService();
417	try {
418	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
419	assertTrue(r.isEmpty());
420	} finally {
421	joinPool(e);
422	}
423	}
424
425	/**
426	* invokeAll(c) throws NPE if c has null elements
427	*/
428	public void testInvokeAll3() throws InterruptedException {
429	ExecutorService e = new DirectExecutorService();
430	try {
431	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
432	l.add(new StringTask());
433	l.add(null);
434	e.invokeAll(l);
435	shouldThrow();
436	} catch (NullPointerException success) {
437	} finally {
438	joinPool(e);
439	}
440	}
441
442	/**
443	* get of returned element of invokeAll(c) throws exception on failed task
444	*/
445	public void testInvokeAll4() throws Exception {
446	ExecutorService e = new DirectExecutorService();
447	try {
448	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
449	l.add(new NPETask());
450	List<Future<String>> result = e.invokeAll(l);
451	assertEquals(1, result.size());
452	for (Future<String> future : result) {
453	try {
454	future.get();
455	shouldThrow();
456	} catch (ExecutionException success) {
457	Throwable cause = success.getCause();
458	assertTrue(cause instanceof NullPointerException);
459	}
460	}
461	} finally {
462	joinPool(e);
463	}
464	}
465
466	/**
467	* invokeAll(c) returns results of all completed tasks in c
468	*/
469	public void testInvokeAll5() throws Exception {
470	ExecutorService e = new DirectExecutorService();
471	try {
472	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
473	l.add(new StringTask());
474	l.add(new StringTask());
475	List<Future<String>> result = e.invokeAll(l);
476	assertEquals(2, result.size());
477	for (Future<String> future : result)
478	assertSame(TEST_STRING, future.get());
479	} finally {
480	joinPool(e);
481	}
482	}
483
484
485	/**
486	* timed invokeAny(null) throws NPE
487	*/
488	public void testTimedInvokeAny1() throws Exception {
489	ExecutorService e = new DirectExecutorService();
490	try {
491	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
492	shouldThrow();
493	} catch (NullPointerException success) {
494	} finally {
495	joinPool(e);
496	}
497	}
498
499	/**
500	* timed invokeAny(null time unit) throws NPE
501	*/
502	public void testTimedInvokeAnyNullTimeUnit() throws Exception {
503	ExecutorService e = new DirectExecutorService();
504	try {
505	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
506	l.add(new StringTask());
507	e.invokeAny(l, MEDIUM_DELAY_MS, null);
508	shouldThrow();
509	} catch (NullPointerException success) {
510	} finally {
511	joinPool(e);
512	}
513	}
514
515	/**
516	* timed invokeAny(empty collection) throws IAE
517	*/
518	public void testTimedInvokeAny2() throws Exception {
519	ExecutorService e = new DirectExecutorService();
520	try {
521	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
522	shouldThrow();
523	} catch (IllegalArgumentException success) {
524	} finally {
525	joinPool(e);
526	}
527	}
528
529	/**
530	* timed invokeAny(c) throws NPE if c has null elements
531	*/
532	public void testTimedInvokeAny3() throws Exception {
533	final CountDownLatch latch = new CountDownLatch(1);
534	ExecutorService e = new DirectExecutorService();
535	try {
536	ArrayList<Callable<Integer>> l
537	= new ArrayList<Callable<Integer>>();
538	l.add(new Callable<Integer>() {
539	public Integer call() { return 5/0; }});
540	l.add(null);
541	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
542	shouldThrow();
543	} catch (NullPointerException success) {
544	} finally {
545	latch.countDown();
546	joinPool(e);
547	}
548	}
549
550	/**
551	* timed invokeAny(c) throws ExecutionException if no task completes
552	*/
553	public void testTimedInvokeAny4() throws Exception {
554	ExecutorService e = new DirectExecutorService();
555	try {
556	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
557	l.add(new NPETask());
558	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
559	shouldThrow();
560	} catch (ExecutionException success) {
561	assertTrue(success.getCause() instanceof NullPointerException);
562	} finally {
563	joinPool(e);
564	}
565	}
566
567	/**
568	* timed invokeAny(c) returns result of some task in c
569	*/
570	public void testTimedInvokeAny5() throws Exception {
571	ExecutorService e = new DirectExecutorService();
572	try {
573	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
574	l.add(new StringTask());
575	l.add(new StringTask());
576	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
577	assertSame(TEST_STRING, result);
578	} finally {
579	joinPool(e);
580	}
581	}
582
583	/**
584	* timed invokeAll(null) throws NPE
585	*/
586	public void testTimedInvokeAll1() throws InterruptedException {
587	ExecutorService e = new DirectExecutorService();
588	try {
589	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
590	shouldThrow();
591	} catch (NullPointerException success) {
592	} finally {
593	joinPool(e);
594	}
595	}
596
597	/**
598	* timed invokeAll(null time unit) throws NPE
599	*/
600	public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
601	ExecutorService e = new DirectExecutorService();
602	try {
603	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
604	l.add(new StringTask());
605	e.invokeAll(l, MEDIUM_DELAY_MS, null);
606	shouldThrow();
607	} catch (NullPointerException success) {
608	} finally {
609	joinPool(e);
610	}
611	}
612
613	/**
614	* timed invokeAll(empty collection) returns empty collection
615	*/
616	public void testTimedInvokeAll2() throws InterruptedException {
617	ExecutorService e = new DirectExecutorService();
618	try {
619	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
620	assertTrue(r.isEmpty());
621	} finally {
622	joinPool(e);
623	}
624	}
625
626	/**
627	* timed invokeAll(c) throws NPE if c has null elements
628	*/
629	public void testTimedInvokeAll3() throws InterruptedException {
630	ExecutorService e = new DirectExecutorService();
631	try {
632	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
633	l.add(new StringTask());
634	l.add(null);
635	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
636	shouldThrow();
637	} catch (NullPointerException success) {
638	} finally {
639	joinPool(e);
640	}
641	}
642
643	/**
644	* get of returned element of invokeAll(c) throws exception on failed task
645	*/
646	public void testTimedInvokeAll4() throws Exception {
647	ExecutorService e = new DirectExecutorService();
648	try {
649	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
650	l.add(new NPETask());
651	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
652	assertEquals(1, result.size());
653	for (Future<String> future : result) {
654	try {
655	future.get();
656	shouldThrow();
657	} catch (ExecutionException success) {
658	assertTrue(success.getCause() instanceof NullPointerException);
659	}
660	}
661	} finally {
662	joinPool(e);
663	}
664	}
665
666	/**
667	* timed invokeAll(c) returns results of all completed tasks in c
668	*/
669	public void testTimedInvokeAll5() throws Exception {
670	ExecutorService e = new DirectExecutorService();
671	try {
672	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
673	l.add(new StringTask());
674	l.add(new StringTask());
675	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
676	assertEquals(2, result.size());
677	for (Future<String> future : result)
678	assertSame(TEST_STRING, future.get());
679	} finally {
680	joinPool(e);
681	}
682	}
683
684	/**
685	* timed invokeAll cancels tasks not completed by timeout
686	*/
687	public void testTimedInvokeAll6() throws InterruptedException {
688	ExecutorService e = new DirectExecutorService();
689	try {
690	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
691	l.add(new StringTask());
692	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
693	l.add(new StringTask());
694	List<Future<String>> result = e.invokeAll(l, SMALL_DELAY_MS, MILLISECONDS);
695	assertEquals(3, result.size());
696	Iterator<Future<String>> it = result.iterator();
697	Future<String> f1 = it.next();
698	Future<String> f2 = it.next();
699	Future<String> f3 = it.next();
700	assertTrue(f1.isDone());
701	assertFalse(f1.isCancelled());
702	assertTrue(f2.isDone());
703	assertTrue(f3.isDone());
704	assertTrue(f3.isCancelled());
705	} finally {
706	joinPool(e);
707	}
708	}
709
710	}