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 {
        ExecutorService e = new DirectExecutorService();
        List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
        l.add(new Callable<Integer>() {
                  public Integer call() { return 5/0; }});
        l.add(null);
        try {
            e.invokeAny(l);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAny(c) throws ExecutionException if no task in c completes
     */
    public void testInvokeAny4() throws InterruptedException {
        ExecutorService e = new DirectExecutorService();
        List<Callable<String>> l = new ArrayList<Callable<String>>();
        l.add(new NPETask());
        try {
            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 {
            List<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();
        List<Callable<String>> l = new ArrayList<Callable<String>>();
        l.add(new StringTask());
        l.add(null);
        try {
            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 {
            List<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            List<Future<String>> futures = e.invokeAll(l);
            assertEquals(1, futures.size());
            try {
                futures.get(0).get();
                shouldThrow();
            } catch (ExecutionException success) {
                assertTrue(success.getCause() 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 {
            List<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            List<Future<String>> futures = e.invokeAll(l);
            assertEquals(2, futures.size());
            for (Future<String> future : futures)
                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();
        List<Callable<String>> l = new ArrayList<Callable<String>>();
        l.add(new StringTask());
        try {
            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 {
        ExecutorService e = new DirectExecutorService();
        List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
        l.add(new Callable<Integer>() {
                  public Integer call() { return 5/0; }});
        l.add(null);
        try {
            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAny(c) throws ExecutionException if no task completes
     */
    public void testTimedInvokeAny4() throws Exception {
        ExecutorService e = new DirectExecutorService();
        List<Callable<String>> l = new ArrayList<Callable<String>>();
        l.add(new NPETask());
        try {
            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 {
            List<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();
        List<Callable<String>> l = new ArrayList<Callable<String>>();
        l.add(new StringTask());
        try {
            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();
        List<Callable<String>> l = new ArrayList<Callable<String>>();
        l.add(new StringTask());
        l.add(null);
        try {
            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 {
            List<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            List<Future<String>> futures =
                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
            assertEquals(1, futures.size());
            try {
                futures.get(0).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 {
            List<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            List<Future<String>> futures =
                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
            assertEquals(2, futures.size());
            for (Future<String> future : futures)
                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 {
            List<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>> futures =
                e.invokeAll(l, SMALL_DELAY_MS, MILLISECONDS);
            assertEquals(3, futures.size());
            Iterator<Future<String>> it = futures.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.22
Committed:	Tue Dec 1 22:51:44 2009 UTC (14 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.21:	+55 -63 lines
Log Message:	various improvements for invokeAll and invokeAny tests
#	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	ExecutorService e = new DirectExecutorService();
349	List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
350	l.add(new Callable<Integer>() {
351	public Integer call() { return 5/0; }});
352	l.add(null);
353	try {
354	e.invokeAny(l);
355	shouldThrow();
356	} catch (NullPointerException success) {
357	} finally {
358	joinPool(e);
359	}
360	}
361
362	/**
363	* invokeAny(c) throws ExecutionException if no task in c completes
364	*/
365	public void testInvokeAny4() throws InterruptedException {
366	ExecutorService e = new DirectExecutorService();
367	List<Callable<String>> l = new ArrayList<Callable<String>>();
368	l.add(new NPETask());
369	try {
370	e.invokeAny(l);
371	shouldThrow();
372	} catch (ExecutionException success) {
373	assertTrue(success.getCause() instanceof NullPointerException);
374	} finally {
375	joinPool(e);
376	}
377	}
378
379	/**
380	* invokeAny(c) returns result of some task in c if at least one completes
381	*/
382	public void testInvokeAny5() throws Exception {
383	ExecutorService e = new DirectExecutorService();
384	try {
385	List<Callable<String>> l = new ArrayList<Callable<String>>();
386	l.add(new StringTask());
387	l.add(new StringTask());
388	String result = e.invokeAny(l);
389	assertSame(TEST_STRING, result);
390	} finally {
391	joinPool(e);
392	}
393	}
394
395	/**
396	* invokeAll(null) throws NPE
397	*/
398	public void testInvokeAll1() throws InterruptedException {
399	ExecutorService e = new DirectExecutorService();
400	try {
401	e.invokeAll(null);
402	shouldThrow();
403	} catch (NullPointerException success) {
404	} finally {
405	joinPool(e);
406	}
407	}
408
409	/**
410	* invokeAll(empty collection) returns empty collection
411	*/
412	public void testInvokeAll2() throws InterruptedException {
413	ExecutorService e = new DirectExecutorService();
414	try {
415	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
416	assertTrue(r.isEmpty());
417	} finally {
418	joinPool(e);
419	}
420	}
421
422	/**
423	* invokeAll(c) throws NPE if c has null elements
424	*/
425	public void testInvokeAll3() throws InterruptedException {
426	ExecutorService e = new DirectExecutorService();
427	List<Callable<String>> l = new ArrayList<Callable<String>>();
428	l.add(new StringTask());
429	l.add(null);
430	try {
431	e.invokeAll(l);
432	shouldThrow();
433	} catch (NullPointerException success) {
434	} finally {
435	joinPool(e);
436	}
437	}
438
439	/**
440	* get of returned element of invokeAll(c) throws exception on failed task
441	*/
442	public void testInvokeAll4() throws Exception {
443	ExecutorService e = new DirectExecutorService();
444	try {
445	List<Callable<String>> l = new ArrayList<Callable<String>>();
446	l.add(new NPETask());
447	List<Future<String>> futures = e.invokeAll(l);
448	assertEquals(1, futures.size());
449	try {
450	futures.get(0).get();
451	shouldThrow();
452	} catch (ExecutionException success) {
453	assertTrue(success.getCause() instanceof NullPointerException);
454	}
455	} finally {
456	joinPool(e);
457	}
458	}
459
460	/**
461	* invokeAll(c) returns results of all completed tasks in c
462	*/
463	public void testInvokeAll5() throws Exception {
464	ExecutorService e = new DirectExecutorService();
465	try {
466	List<Callable<String>> l = new ArrayList<Callable<String>>();
467	l.add(new StringTask());
468	l.add(new StringTask());
469	List<Future<String>> futures = e.invokeAll(l);
470	assertEquals(2, futures.size());
471	for (Future<String> future : futures)
472	assertSame(TEST_STRING, future.get());
473	} finally {
474	joinPool(e);
475	}
476	}
477
478
479	/**
480	* timed invokeAny(null) throws NPE
481	*/
482	public void testTimedInvokeAny1() throws Exception {
483	ExecutorService e = new DirectExecutorService();
484	try {
485	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
486	shouldThrow();
487	} catch (NullPointerException success) {
488	} finally {
489	joinPool(e);
490	}
491	}
492
493	/**
494	* timed invokeAny(null time unit) throws NPE
495	*/
496	public void testTimedInvokeAnyNullTimeUnit() throws Exception {
497	ExecutorService e = new DirectExecutorService();
498	List<Callable<String>> l = new ArrayList<Callable<String>>();
499	l.add(new StringTask());
500	try {
501	e.invokeAny(l, MEDIUM_DELAY_MS, null);
502	shouldThrow();
503	} catch (NullPointerException success) {
504	} finally {
505	joinPool(e);
506	}
507	}
508
509	/**
510	* timed invokeAny(empty collection) throws IAE
511	*/
512	public void testTimedInvokeAny2() throws Exception {
513	ExecutorService e = new DirectExecutorService();
514	try {
515	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
516	shouldThrow();
517	} catch (IllegalArgumentException success) {
518	} finally {
519	joinPool(e);
520	}
521	}
522
523	/**
524	* timed invokeAny(c) throws NPE if c has null elements
525	*/
526	public void testTimedInvokeAny3() throws Exception {
527	ExecutorService e = new DirectExecutorService();
528	List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
529	l.add(new Callable<Integer>() {
530	public Integer call() { return 5/0; }});
531	l.add(null);
532	try {
533	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
534	shouldThrow();
535	} catch (NullPointerException success) {
536	} finally {
537	joinPool(e);
538	}
539	}
540
541	/**
542	* timed invokeAny(c) throws ExecutionException if no task completes
543	*/
544	public void testTimedInvokeAny4() throws Exception {
545	ExecutorService e = new DirectExecutorService();
546	List<Callable<String>> l = new ArrayList<Callable<String>>();
547	l.add(new NPETask());
548	try {
549	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
550	shouldThrow();
551	} catch (ExecutionException success) {
552	assertTrue(success.getCause() instanceof NullPointerException);
553	} finally {
554	joinPool(e);
555	}
556	}
557
558	/**
559	* timed invokeAny(c) returns result of some task in c
560	*/
561	public void testTimedInvokeAny5() throws Exception {
562	ExecutorService e = new DirectExecutorService();
563	try {
564	List<Callable<String>> l = new ArrayList<Callable<String>>();
565	l.add(new StringTask());
566	l.add(new StringTask());
567	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
568	assertSame(TEST_STRING, result);
569	} finally {
570	joinPool(e);
571	}
572	}
573
574	/**
575	* timed invokeAll(null) throws NPE
576	*/
577	public void testTimedInvokeAll1() throws InterruptedException {
578	ExecutorService e = new DirectExecutorService();
579	try {
580	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
581	shouldThrow();
582	} catch (NullPointerException success) {
583	} finally {
584	joinPool(e);
585	}
586	}
587
588	/**
589	* timed invokeAll(null time unit) throws NPE
590	*/
591	public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
592	ExecutorService e = new DirectExecutorService();
593	List<Callable<String>> l = new ArrayList<Callable<String>>();
594	l.add(new StringTask());
595	try {
596	e.invokeAll(l, MEDIUM_DELAY_MS, null);
597	shouldThrow();
598	} catch (NullPointerException success) {
599	} finally {
600	joinPool(e);
601	}
602	}
603
604	/**
605	* timed invokeAll(empty collection) returns empty collection
606	*/
607	public void testTimedInvokeAll2() throws InterruptedException {
608	ExecutorService e = new DirectExecutorService();
609	try {
610	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
611	assertTrue(r.isEmpty());
612	} finally {
613	joinPool(e);
614	}
615	}
616
617	/**
618	* timed invokeAll(c) throws NPE if c has null elements
619	*/
620	public void testTimedInvokeAll3() throws InterruptedException {
621	ExecutorService e = new DirectExecutorService();
622	List<Callable<String>> l = new ArrayList<Callable<String>>();
623	l.add(new StringTask());
624	l.add(null);
625	try {
626	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
627	shouldThrow();
628	} catch (NullPointerException success) {
629	} finally {
630	joinPool(e);
631	}
632	}
633
634	/**
635	* get of returned element of invokeAll(c) throws exception on failed task
636	*/
637	public void testTimedInvokeAll4() throws Exception {
638	ExecutorService e = new DirectExecutorService();
639	try {
640	List<Callable<String>> l = new ArrayList<Callable<String>>();
641	l.add(new NPETask());
642	List<Future<String>> futures =
643	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
644	assertEquals(1, futures.size());
645	try {
646	futures.get(0).get();
647	shouldThrow();
648	} catch (ExecutionException success) {
649	assertTrue(success.getCause() instanceof NullPointerException);
650	}
651	} finally {
652	joinPool(e);
653	}
654	}
655
656	/**
657	* timed invokeAll(c) returns results of all completed tasks in c
658	*/
659	public void testTimedInvokeAll5() throws Exception {
660	ExecutorService e = new DirectExecutorService();
661	try {
662	List<Callable<String>> l = new ArrayList<Callable<String>>();
663	l.add(new StringTask());
664	l.add(new StringTask());
665	List<Future<String>> futures =
666	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
667	assertEquals(2, futures.size());
668	for (Future<String> future : futures)
669	assertSame(TEST_STRING, future.get());
670	} finally {
671	joinPool(e);
672	}
673	}
674
675	/**
676	* timed invokeAll cancels tasks not completed by timeout
677	*/
678	public void testTimedInvokeAll6() throws InterruptedException {
679	ExecutorService e = new DirectExecutorService();
680	try {
681	List<Callable<String>> l = new ArrayList<Callable<String>>();
682	l.add(new StringTask());
683	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
684	l.add(new StringTask());
685	List<Future<String>> futures =
686	e.invokeAll(l, SMALL_DELAY_MS, MILLISECONDS);
687	assertEquals(3, futures.size());
688	Iterator<Future<String>> it = futures.iterator();
689	Future<String> f1 = it.next();
690	Future<String> f2 = it.next();
691	Future<String> f3 = it.next();
692	assertTrue(f1.isDone());
693	assertFalse(f1.isCancelled());
694	assertTrue(f2.isDone());
695	assertTrue(f3.isDone());
696	assertTrue(f3.isCancelled());
697	} finally {
698	joinPool(e);
699	}
700	}
701
702	}