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