test/tck/AbstractExecutorServiceTest.java

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


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

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

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

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


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

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

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


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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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