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 static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.AbstractExecutorService;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import junit.framework.Test;
import junit.framework.TestSuite;

public class AbstractExecutorServiceTest extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }
    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() {
        ExecutorService e = new DirectExecutorService();
        try {
            e.submit((Runnable) null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

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