test/tck/AbstractExecutorServiceTest.java

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

import static java.util.concurrent.TimeUnit.MILLISECONDS;

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

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

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

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

    /**
     * execute(runnable) runs it to completion
     */
    public void testExecuteRunnable() throws Exception {
        ExecutorService e = new DirectExecutorService();
        final AtomicBoolean done = new AtomicBoolean(false);
        Future<?> future = e.submit(new CheckedRunnable() {
            public void realRun() {
                done.set(true);
            }});
        assertNull(future.get());
        assertNull(future.get(0, MILLISECONDS));
        assertTrue(done.get());
        assertTrue(future.isDone());
        assertFalse(future.isCancelled());
    }

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

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

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

    /**
     * A submitted privileged action runs to completion
     */
    public void testSubmitPrivilegedAction() throws Exception {
        Runnable r = new CheckedRunnable() {
            public void realRun() throws Exception {
                ExecutorService e = new DirectExecutorService();
                Future future = e.submit(Executors.callable(new PrivilegedAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

                assertSame(TEST_STRING, future.get());
            }};

        runWithPermissions(r,
                           new RuntimePermission("getClassLoader"),
                           new RuntimePermission("setContextClassLoader"),
                           new RuntimePermission("modifyThread"));
    }

    /**
     * A submitted privileged exception action runs to completion
     */
    public void testSubmitPrivilegedExceptionAction() throws Exception {
        Runnable r = new CheckedRunnable() {
            public void realRun() throws Exception {
                ExecutorService e = new DirectExecutorService();
                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

                assertSame(TEST_STRING, future.get());
            }};

        runWithPermissions(r);
    }

    /**
     * A submitted failed privileged exception action reports exception
     */
    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
        Runnable r = new CheckedRunnable() {
            public void realRun() throws Exception {
                ExecutorService e = new DirectExecutorService();
                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        throw new IndexOutOfBoundsException();
                    }}));

                try {
                    future.get();
                    shouldThrow();
                } catch (ExecutionException success) {
                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
                }}};

        runWithPermissions(r);
    }

    /**
     * execute(null runnable) throws NPE
     */
    public void testExecuteNullRunnable() {
        ExecutorService e = new DirectExecutorService();
        try {
            e.submit((Runnable) null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * submit(null callable) throws NPE
     */
    public void testSubmitNullCallable() {
        ExecutorService e = new DirectExecutorService();
        try {
            e.submit((Callable) null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * submit(callable).get() throws InterruptedException if interrupted
     */
    public void testInterruptedSubmit() throws InterruptedException {
        final CountDownLatch submitted    = new CountDownLatch(1);
        final CountDownLatch quittingTime = new CountDownLatch(1);
        final ExecutorService p
            = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,
                                     new ArrayBlockingQueue<Runnable>(10));
        final Callable<Void> awaiter = new CheckedCallable<Void>() {
            public Void realCall() throws InterruptedException {
                quittingTime.await();
                return null;
            }};
        try {
            Thread t = new Thread(new CheckedInterruptedRunnable() {
                public void realRun() throws Exception {
                    Future<Void> future = p.submit(awaiter);
                    submitted.countDown();
                    future.get();
                }});
            t.start();
            submitted.await();
            t.interrupt();
            t.join();
        } finally {
            quittingTime.countDown();
            joinPool(p);
        }
    }

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

        Callable c = new Callable() {
            public Object call() { throw new ArithmeticException(); }};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * timed invokeAll(c) returns results of all completed tasks in c
     */
    public void testTimedInvokeAll5() throws Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            List<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            List<Future<String>> futures =
                e.invokeAll(l, LONG_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 Exception {
        ExecutorService e = new DirectExecutorService();
        try {
            for (long timeout = timeoutMillis();;) {
                List<Callable<String>> tasks = new ArrayList<>();
                tasks.add(new StringTask("0"));
                tasks.add(Executors.callable(possiblyInterruptedRunnable(timeout),
                                             TEST_STRING));
                tasks.add(new StringTask("2"));
                long startTime = System.nanoTime();
                List<Future<String>> futures =
                    e.invokeAll(tasks, timeout, MILLISECONDS);
                assertEquals(tasks.size(), futures.size());
                assertTrue(millisElapsedSince(startTime) >= timeout);
                for (Future future : futures)
                    assertTrue(future.isDone());
                try {
                    assertEquals("0", futures.get(0).get());
                    assertEquals(TEST_STRING, futures.get(1).get());
                } catch (CancellationException retryWithLongerTimeout) {
                    // unusual delay before starting second task
                    timeout *= 2;
                    if (timeout >= LONG_DELAY_MS / 2)
                        fail("expected exactly one task to be cancelled");
                    continue;
                }
                assertTrue(futures.get(2).isCancelled());
                break;
            }
        } finally {
            joinPool(e);
        }
    }

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