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);
        }
    }


    /**
     * 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 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.25
Committed:	Thu Sep 16 02:54:10 2010 UTC (13 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.24:	+26 -17 lines
Log Message:	Fix flakiness in testInterruptedSubmit
#	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	* submit(callable).get() throws InterruptedException if interrupted
216	*/
217	public void testInterruptedSubmit() throws InterruptedException {
218	final CountDownLatch submitted = new CountDownLatch(1);
219	final CountDownLatch quittingTime = new CountDownLatch(1);
220	final ExecutorService p
221	= new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,
222	new ArrayBlockingQueue<Runnable>(10));
223	final Callable<Void> awaiter = new CheckedCallable<Void>() {
224	public Void realCall() throws InterruptedException {
225	quittingTime.await();
226	return null;
227	}};
228	try {
229	Thread t = new Thread(new CheckedInterruptedRunnable() {
230	public void realRun() throws Exception {
231	Future<Void> future = p.submit(awaiter);
232	submitted.countDown();
233	future.get();
234	}});
235	t.start();
236	submitted.await();
237	t.interrupt();
238	t.join();
239	} finally {
240	quittingTime.countDown();
241	joinPool(p);
242	}
243	}
244
245	/**
246	* get of submitted callable throws InterruptedException if callable
247	* interrupted
248	*/
249	public void testSubmitIE() throws InterruptedException {
250	final ThreadPoolExecutor p =
251	new ThreadPoolExecutor(1, 1,
252	60, TimeUnit.SECONDS,
253	new ArrayBlockingQueue<Runnable>(10));
254
255	Thread t = new Thread(new CheckedInterruptedRunnable() {
256	public void realRun() throws Exception {
257	p.submit(new SmallCallable()).get();
258	}});
259
260	t.start();
261	Thread.sleep(SHORT_DELAY_MS);
262	t.interrupt();
263	t.join();
264	joinPool(p);
265	}
266
267	/**
268	* get of submit(callable) throws ExecutionException if callable
269	* throws exception
270	*/
271	public void testSubmitEE() throws InterruptedException {
272	ThreadPoolExecutor p =
273	new ThreadPoolExecutor(1, 1,
274	60, TimeUnit.SECONDS,
275	new ArrayBlockingQueue<Runnable>(10));
276
277	Callable c = new Callable() {
278	public Object call() { return 5/0; }};
279
280	try {
281	p.submit(c).get();
282	shouldThrow();
283	} catch (ExecutionException success) {
284	assertTrue(success.getCause() instanceof ArithmeticException);
285	}
286	joinPool(p);
287	}
288
289	/**
290	* invokeAny(null) throws NPE
291	*/
292	public void testInvokeAny1()
293	throws InterruptedException, ExecutionException {
294	ExecutorService e = new DirectExecutorService();
295	try {
296	e.invokeAny(null);
297	shouldThrow();
298	} catch (NullPointerException success) {
299	} finally {
300	joinPool(e);
301	}
302	}
303
304	/**
305	* invokeAny(empty collection) throws IAE
306	*/
307	public void testInvokeAny2()
308	throws InterruptedException, ExecutionException {
309	ExecutorService e = new DirectExecutorService();
310	try {
311	e.invokeAny(new ArrayList<Callable<String>>());
312	shouldThrow();
313	} catch (IllegalArgumentException success) {
314	} finally {
315	joinPool(e);
316	}
317	}
318
319	/**
320	* invokeAny(c) throws NPE if c has null elements
321	*/
322	public void testInvokeAny3() throws Exception {
323	ExecutorService e = new DirectExecutorService();
324	List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
325	l.add(new Callable<Integer>() {
326	public Integer call() { return 5/0; }});
327	l.add(null);
328	try {
329	e.invokeAny(l);
330	shouldThrow();
331	} catch (NullPointerException success) {
332	} finally {
333	joinPool(e);
334	}
335	}
336
337	/**
338	* invokeAny(c) throws ExecutionException if no task in c completes
339	*/
340	public void testInvokeAny4() throws InterruptedException {
341	ExecutorService e = new DirectExecutorService();
342	List<Callable<String>> l = new ArrayList<Callable<String>>();
343	l.add(new NPETask());
344	try {
345	e.invokeAny(l);
346	shouldThrow();
347	} catch (ExecutionException success) {
348	assertTrue(success.getCause() instanceof NullPointerException);
349	} finally {
350	joinPool(e);
351	}
352	}
353
354	/**
355	* invokeAny(c) returns result of some task in c if at least one completes
356	*/
357	public void testInvokeAny5() throws Exception {
358	ExecutorService e = new DirectExecutorService();
359	try {
360	List<Callable<String>> l = new ArrayList<Callable<String>>();
361	l.add(new StringTask());
362	l.add(new StringTask());
363	String result = e.invokeAny(l);
364	assertSame(TEST_STRING, result);
365	} finally {
366	joinPool(e);
367	}
368	}
369
370	/**
371	* invokeAll(null) throws NPE
372	*/
373	public void testInvokeAll1() throws InterruptedException {
374	ExecutorService e = new DirectExecutorService();
375	try {
376	e.invokeAll(null);
377	shouldThrow();
378	} catch (NullPointerException success) {
379	} finally {
380	joinPool(e);
381	}
382	}
383
384	/**
385	* invokeAll(empty collection) returns empty collection
386	*/
387	public void testInvokeAll2() throws InterruptedException {
388	ExecutorService e = new DirectExecutorService();
389	try {
390	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
391	assertTrue(r.isEmpty());
392	} finally {
393	joinPool(e);
394	}
395	}
396
397	/**
398	* invokeAll(c) throws NPE if c has null elements
399	*/
400	public void testInvokeAll3() throws InterruptedException {
401	ExecutorService e = new DirectExecutorService();
402	List<Callable<String>> l = new ArrayList<Callable<String>>();
403	l.add(new StringTask());
404	l.add(null);
405	try {
406	e.invokeAll(l);
407	shouldThrow();
408	} catch (NullPointerException success) {
409	} finally {
410	joinPool(e);
411	}
412	}
413
414	/**
415	* get of returned element of invokeAll(c) throws exception on failed task
416	*/
417	public void testInvokeAll4() throws Exception {
418	ExecutorService e = new DirectExecutorService();
419	try {
420	List<Callable<String>> l = new ArrayList<Callable<String>>();
421	l.add(new NPETask());
422	List<Future<String>> futures = e.invokeAll(l);
423	assertEquals(1, futures.size());
424	try {
425	futures.get(0).get();
426	shouldThrow();
427	} catch (ExecutionException success) {
428	assertTrue(success.getCause() instanceof NullPointerException);
429	}
430	} finally {
431	joinPool(e);
432	}
433	}
434
435	/**
436	* invokeAll(c) returns results of all completed tasks in c
437	*/
438	public void testInvokeAll5() throws Exception {
439	ExecutorService e = new DirectExecutorService();
440	try {
441	List<Callable<String>> l = new ArrayList<Callable<String>>();
442	l.add(new StringTask());
443	l.add(new StringTask());
444	List<Future<String>> futures = e.invokeAll(l);
445	assertEquals(2, futures.size());
446	for (Future<String> future : futures)
447	assertSame(TEST_STRING, future.get());
448	} finally {
449	joinPool(e);
450	}
451	}
452
453
454	/**
455	* timed invokeAny(null) throws NPE
456	*/
457	public void testTimedInvokeAny1() throws Exception {
458	ExecutorService e = new DirectExecutorService();
459	try {
460	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
461	shouldThrow();
462	} catch (NullPointerException success) {
463	} finally {
464	joinPool(e);
465	}
466	}
467
468	/**
469	* timed invokeAny(null time unit) throws NPE
470	*/
471	public void testTimedInvokeAnyNullTimeUnit() throws Exception {
472	ExecutorService e = new DirectExecutorService();
473	List<Callable<String>> l = new ArrayList<Callable<String>>();
474	l.add(new StringTask());
475	try {
476	e.invokeAny(l, MEDIUM_DELAY_MS, null);
477	shouldThrow();
478	} catch (NullPointerException success) {
479	} finally {
480	joinPool(e);
481	}
482	}
483
484	/**
485	* timed invokeAny(empty collection) throws IAE
486	*/
487	public void testTimedInvokeAny2() throws Exception {
488	ExecutorService e = new DirectExecutorService();
489	try {
490	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
491	shouldThrow();
492	} catch (IllegalArgumentException success) {
493	} finally {
494	joinPool(e);
495	}
496	}
497
498	/**
499	* timed invokeAny(c) throws NPE if c has null elements
500	*/
501	public void testTimedInvokeAny3() throws Exception {
502	ExecutorService e = new DirectExecutorService();
503	List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
504	l.add(new Callable<Integer>() {
505	public Integer call() { return 5/0; }});
506	l.add(null);
507	try {
508	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
509	shouldThrow();
510	} catch (NullPointerException success) {
511	} finally {
512	joinPool(e);
513	}
514	}
515
516	/**
517	* timed invokeAny(c) throws ExecutionException if no task completes
518	*/
519	public void testTimedInvokeAny4() throws Exception {
520	ExecutorService e = new DirectExecutorService();
521	List<Callable<String>> l = new ArrayList<Callable<String>>();
522	l.add(new NPETask());
523	try {
524	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
525	shouldThrow();
526	} catch (ExecutionException success) {
527	assertTrue(success.getCause() instanceof NullPointerException);
528	} finally {
529	joinPool(e);
530	}
531	}
532
533	/**
534	* timed invokeAny(c) returns result of some task in c
535	*/
536	public void testTimedInvokeAny5() throws Exception {
537	ExecutorService e = new DirectExecutorService();
538	try {
539	List<Callable<String>> l = new ArrayList<Callable<String>>();
540	l.add(new StringTask());
541	l.add(new StringTask());
542	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
543	assertSame(TEST_STRING, result);
544	} finally {
545	joinPool(e);
546	}
547	}
548
549	/**
550	* timed invokeAll(null) throws NPE
551	*/
552	public void testTimedInvokeAll1() throws InterruptedException {
553	ExecutorService e = new DirectExecutorService();
554	try {
555	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
556	shouldThrow();
557	} catch (NullPointerException success) {
558	} finally {
559	joinPool(e);
560	}
561	}
562
563	/**
564	* timed invokeAll(null time unit) throws NPE
565	*/
566	public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
567	ExecutorService e = new DirectExecutorService();
568	List<Callable<String>> l = new ArrayList<Callable<String>>();
569	l.add(new StringTask());
570	try {
571	e.invokeAll(l, MEDIUM_DELAY_MS, null);
572	shouldThrow();
573	} catch (NullPointerException success) {
574	} finally {
575	joinPool(e);
576	}
577	}
578
579	/**
580	* timed invokeAll(empty collection) returns empty collection
581	*/
582	public void testTimedInvokeAll2() throws InterruptedException {
583	ExecutorService e = new DirectExecutorService();
584	try {
585	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
586	assertTrue(r.isEmpty());
587	} finally {
588	joinPool(e);
589	}
590	}
591
592	/**
593	* timed invokeAll(c) throws NPE if c has null elements
594	*/
595	public void testTimedInvokeAll3() throws InterruptedException {
596	ExecutorService e = new DirectExecutorService();
597	List<Callable<String>> l = new ArrayList<Callable<String>>();
598	l.add(new StringTask());
599	l.add(null);
600	try {
601	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
602	shouldThrow();
603	} catch (NullPointerException success) {
604	} finally {
605	joinPool(e);
606	}
607	}
608
609	/**
610	* get of returned element of invokeAll(c) throws exception on failed task
611	*/
612	public void testTimedInvokeAll4() throws Exception {
613	ExecutorService e = new DirectExecutorService();
614	try {
615	List<Callable<String>> l = new ArrayList<Callable<String>>();
616	l.add(new NPETask());
617	List<Future<String>> futures =
618	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
619	assertEquals(1, futures.size());
620	try {
621	futures.get(0).get();
622	shouldThrow();
623	} catch (ExecutionException success) {
624	assertTrue(success.getCause() instanceof NullPointerException);
625	}
626	} finally {
627	joinPool(e);
628	}
629	}
630
631	/**
632	* timed invokeAll(c) returns results of all completed tasks in c
633	*/
634	public void testTimedInvokeAll5() throws Exception {
635	ExecutorService e = new DirectExecutorService();
636	try {
637	List<Callable<String>> l = new ArrayList<Callable<String>>();
638	l.add(new StringTask());
639	l.add(new StringTask());
640	List<Future<String>> futures =
641	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
642	assertEquals(2, futures.size());
643	for (Future<String> future : futures)
644	assertSame(TEST_STRING, future.get());
645	} finally {
646	joinPool(e);
647	}
648	}
649
650	/**
651	* timed invokeAll cancels tasks not completed by timeout
652	*/
653	public void testTimedInvokeAll6() throws InterruptedException {
654	ExecutorService e = new DirectExecutorService();
655	try {
656	List<Callable<String>> l = new ArrayList<Callable<String>>();
657	l.add(new StringTask());
658	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
659	l.add(new StringTask());
660	List<Future<String>> futures =
661	e.invokeAll(l, SMALL_DELAY_MS, MILLISECONDS);
662	assertEquals(3, futures.size());
663	Iterator<Future<String>> it = futures.iterator();
664	Future<String> f1 = it.next();
665	Future<String> f2 = it.next();
666	Future<String> f3 = it.next();
667	assertTrue(f1.isDone());
668	assertFalse(f1.isCancelled());
669	assertTrue(f2.isDone());
670	assertTrue(f3.isDone());
671	assertTrue(f3.isCancelled());
672	} finally {
673	joinPool(e);
674	}
675	}
676
677	}