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