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.Collection;
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.emptyList();
        }
        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<Object>() {
                    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<Object>() {
                    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<Object>() {
                    public Object run() throws Exception {
                        throw new IndexOutOfBoundsException();
                    }}));

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

        runWithPermissions(r);
    }

    /**
     * Submitting null tasks throws NullPointerException
     */
    public void testNullTaskSubmission() {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            assertNullTaskSubmissionThrowsNullPointerException(e);
        }
    }

    /**
     * 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 Callable<Void> awaiter = new CheckedCallable<>() {
            public Void realCall() throws InterruptedException {
                assertTrue(quittingTime.await(2*LONG_DELAY_MS, MILLISECONDS));
                return null;
            }};
        final ExecutorService p
            = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,
                                     new ArrayBlockingQueue<Runnable>(10));
        try (PoolCleaner cleaner = cleaner(p, quittingTime)) {
            Thread t = newStartedThread(new CheckedInterruptedRunnable() {
                public void realRun() throws Exception {
                    Future<Void> future = p.submit(awaiter);
                    submitted.countDown();
                    future.get();
                }});

            await(submitted);
            t.interrupt();
            awaitTermination(t);
        }
    }

    /**
     * get of submit(callable) throws ExecutionException if callable
     * throws exception
     */
    public void testSubmitEE() throws InterruptedException {
        final ThreadPoolExecutor p =
            new ThreadPoolExecutor(1, 1,
                                   60, TimeUnit.SECONDS,
                                   new ArrayBlockingQueue<Runnable>(10));
        try (PoolCleaner cleaner = cleaner(p)) {
            Callable<Object> c = new Callable<>() {
                public Object call() { throw new ArithmeticException(); }};
            try {
                p.submit(c).get();
                shouldThrow();
            } catch (ExecutionException success) {
                assertTrue(success.getCause() instanceof ArithmeticException);
            }
        }
    }

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

    /**
     * invokeAny(empty collection) throws IllegalArgumentException
     */
    public void testInvokeAny2() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        final Collection<Callable<String>> emptyCollection
            = Collections.emptyList();
        try (PoolCleaner cleaner = cleaner(e)) {
            try {
                e.invokeAny(emptyCollection);
                shouldThrow();
            } catch (IllegalArgumentException success) {}
        }
    }

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

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

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

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

    /**
     * invokeAll(empty collection) returns empty list
     */
    public void testInvokeAll2() throws InterruptedException {
        final ExecutorService e = new DirectExecutorService();
        final Collection<Callable<String>> emptyCollection
            = Collections.emptyList();
        try (PoolCleaner cleaner = cleaner(e)) {
            List<Future<String>> r = e.invokeAll(emptyCollection);
            assertTrue(r.isEmpty());
        }
    }

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

    /**
     * get of returned element of invokeAll(c) throws exception on failed task
     */
    public void testInvokeAll4() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            List<Callable<String>> l = new ArrayList<>();
            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);
            }
        }
    }

    /**
     * invokeAll(c) returns results of all completed tasks in c
     */
    public void testInvokeAll5() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            List<Callable<String>> l = new ArrayList<>();
            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());
        }
    }

    /**
     * timed invokeAny(null) throws NPE
     */
    public void testTimedInvokeAny1() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            try {
                e.invokeAny(null, randomTimeout(), randomTimeUnit());
                shouldThrow();
            } catch (NullPointerException success) {}
        }
    }

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

    /**
     * timed invokeAny(empty collection) throws IllegalArgumentException
     */
    public void testTimedInvokeAny2() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        final Collection<Callable<String>> emptyCollection
            = Collections.emptyList();
        try (PoolCleaner cleaner = cleaner(e)) {
            try {
                e.invokeAny(emptyCollection, randomTimeout(), randomTimeUnit());
                shouldThrow();
            } catch (IllegalArgumentException success) {}
        }
    }

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

    /**
     * timed invokeAny(c) throws ExecutionException if no task completes
     */
    public void testTimedInvokeAny4() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            long startTime = System.nanoTime();
            List<Callable<String>> l = new ArrayList<>();
            l.add(new NPETask());
            try {
                e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
                shouldThrow();
            } catch (ExecutionException success) {
                assertTrue(success.getCause() instanceof NullPointerException);
            }
            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
        }
    }

    /**
     * timed invokeAny(c) returns result of some task in c
     */
    public void testTimedInvokeAny5() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            long startTime = System.nanoTime();
            List<Callable<String>> l = new ArrayList<>();
            l.add(new StringTask());
            l.add(new StringTask());
            String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
            assertSame(TEST_STRING, result);
            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
        }
    }

    /**
     * timed invokeAll(null) throws NullPointerException
     */
    public void testTimedInvokeAll1() throws InterruptedException {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            try {
                e.invokeAll(null, randomTimeout(), randomTimeUnit());
                shouldThrow();
            } catch (NullPointerException success) {}
        }
    }

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

    /**
     * timed invokeAll(empty collection) returns empty list
     */
    public void testTimedInvokeAll2() throws InterruptedException {
        final ExecutorService e = new DirectExecutorService();
        final Collection<Callable<String>> emptyCollection
            = Collections.emptyList();
        try (PoolCleaner cleaner = cleaner(e)) {
            List<Future<String>> r =
                e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
            assertTrue(r.isEmpty());
        }
    }

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

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

    /**
     * timed invokeAll(c) returns results of all completed tasks in c
     */
    public void testTimedInvokeAll5() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            List<Callable<String>> l = new ArrayList<>();
            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());
        }
    }

    /**
     * timed invokeAll cancels tasks not completed by timeout
     */
    public void testTimedInvokeAll6() throws Exception {
        final ExecutorService e = new DirectExecutorService();
        try (PoolCleaner cleaner = cleaner(e)) {
            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;
            }
        }
    }

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