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/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
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();
        final AtomicBoolean done = new AtomicBoolean(false);
        Future<?> future = e.submit(new CheckedRunnable() {
            public void realRun() {
                done.set(true);
            }});
        assertNull(future.get());
        assertNull(future.get(0, MILLISECONDS));
        assertTrue(done.get());
        assertTrue(future.isDone());
        assertFalse(future.isCancelled());
    }

    /**
     * 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 runs to completion
     */
    public void testSubmitPrivilegedAction() throws Exception {
        Runnable r = new CheckedRunnable() {
            public void realRun() throws Exception {
                ExecutorService e = new DirectExecutorService();
                Future future = e.submit(Executors.callable(new PrivilegedAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

                assertSame(TEST_STRING, future.get());
            }};

        runWithPermissions(r,
                           new RuntimePermission("getClassLoader"),
                           new RuntimePermission("setContextClassLoader"),
                           new RuntimePermission("modifyThread"));
    }

    /**
     * A submitted privileged exception action runs to completion
     */
    public void testSubmitPrivilegedExceptionAction() throws Exception {
        Runnable r = new CheckedRunnable() {
            public void realRun() throws Exception {
                ExecutorService e = new DirectExecutorService();
                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

                assertSame(TEST_STRING, future.get());
            }};

        runWithPermissions(r);
    }

    /**
     * A submitted failed privileged exception action reports exception
     */
    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
        Runnable r = new CheckedRunnable() {
            public void realRun() throws Exception {
                ExecutorService e = new DirectExecutorService();
                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        throw new IndexOutOfBoundsException();
                    }}));

                try {
                    future.get();
                    shouldThrow();
                } catch (ExecutionException success) {
                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
                }}};

        runWithPermissions(r);
    }

    /**
     * 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(callable).get() throws InterruptedException if interrupted
     */
    public void testInterruptedSubmit() throws InterruptedException {
        final CountDownLatch submitted    = new CountDownLatch(1);
        final CountDownLatch quittingTime = new CountDownLatch(1);
        final ExecutorService p
            = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,
                                     new ArrayBlockingQueue<Runnable>(10));
        final Callable<Void> awaiter = new CheckedCallable<Void>() {
            public Void realCall() throws InterruptedException {
                quittingTime.await();
                return null;
            }};
        try {
            Thread t = new Thread(new CheckedInterruptedRunnable() {
                public void realRun() throws Exception {
                    Future<Void> future = p.submit(awaiter);
                    submitted.countDown();
                    future.get();
                }});
            t.start();
            submitted.await();
            t.interrupt();
            t.join();
        } finally {
            quittingTime.countDown();
            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() { throw new ArithmeticException(); }};

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

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

    /**
     * invokeAny(empty collection) throws IAE
     */
    public void testInvokeAny2() throws Exception {
        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<Long>> l = new ArrayList<Callable<Long>>();
        l.add(new Callable<Long>() {
            public Long call() { throw new ArithmeticException(); }});
        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<Long>> l = new ArrayList<Callable<Long>>();
        l.add(new Callable<Long>() {
            public Long call() { throw new ArithmeticException(); }});
        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(possiblyInterruptedRunnable(2 * SHORT_DELAY_MS), TEST_STRING));
            l.add(new StringTask());
            List<Future<String>> futures =
                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
            assertEquals(l.size(), futures.size());
            for (Future future : futures)
                assertTrue(future.isDone());
            assertFalse(futures.get(0).isCancelled());
            assertFalse(futures.get(1).isCancelled());
            assertTrue(futures.get(2).isCancelled());
        } finally {
            joinPool(e);
        }
    }

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