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
#	User	Rev	Content
1	tim	1.1	/*
2	dl	1.10	* 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	jsr166	1.16	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	tim	1.1	*/
8
9
10			import junit.framework.*;
11			import java.util.*;
12			import java.util.concurrent.*;
13	jsr166	1.20	import static java.util.concurrent.TimeUnit.MILLISECONDS;
14	tim	1.1	import java.math.BigInteger;
15			import java.security.*;
16
17	jsr166	1.18	public class AbstractExecutorServiceTest extends JSR166TestCase {
18	tim	1.1	public static void main(String[] args) {
19	jsr166	1.24	junit.textui.TestRunner.run(suite());
20	tim	1.1	}
21			public static Test suite() {
22	dl	1.6	return new TestSuite(AbstractExecutorServiceTest.class);
23	tim	1.1	}
24
25	jsr166	1.16	/**
26	tim	1.1	* A no-frills implementation of AbstractExecutorService, designed
27	dl	1.6	* to test the submit methods only.
28	tim	1.1	*/
29			static class DirectExecutorService extends AbstractExecutorService {
30			public void execute(Runnable r) { r.run(); }
31			public void shutdown() { shutdown = true; }
32	jsr166	1.26	public List<Runnable> shutdownNow() {
33			shutdown = true;
34			return Collections.EMPTY_LIST;
35			}
36	tim	1.1	public boolean isShutdown() { return shutdown; }
37			public boolean isTerminated() { return isShutdown(); }
38	jsr166	1.26	public boolean awaitTermination(long timeout, TimeUnit unit) {
39			return isShutdown();
40			}
41	tim	1.1	private volatile boolean shutdown = false;
42			}
43
44			/**
45	dl	1.12	* execute(runnable) runs it to completion
46	tim	1.1	*/
47	jsr166	1.19	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	tim	1.1	}
55
56
57			/**
58	dl	1.12	* Completed submit(callable) returns result
59	tim	1.1	*/
60	jsr166	1.19	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	tim	1.1	}
66
67	dl	1.6	/**
68	dl	1.12	* Completed submit(runnable) returns successfully
69	dl	1.6	*/
70	jsr166	1.19	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	dl	1.6	}
76
77			/**
78	dl	1.12	* Completed submit(runnable, result) returns result
79	dl	1.6	*/
80	jsr166	1.19	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	dl	1.6	}
86
87	tim	1.1
88			/**
89	jsr166	1.23	* A submitted privileged action runs to completion
90	tim	1.1	*/
91	jsr166	1.19	public void testSubmitPrivilegedAction() throws Exception {
92	jsr166	1.23	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	tim	1.1	public Object run() {
97			return TEST_STRING;
98	dl	1.5	}}));
99	tim	1.1
100	jsr166	1.23	assertSame(TEST_STRING, future.get());
101			}};
102
103			runWithPermissions(r,
104			new RuntimePermission("getClassLoader"),
105			new RuntimePermission("setContextClassLoader"),
106			new RuntimePermission("modifyThread"));
107	tim	1.1	}
108
109			/**
110	jsr166	1.23	* A submitted privileged exception action runs to completion
111	tim	1.1	*/
112	jsr166	1.19	public void testSubmitPrivilegedExceptionAction() throws Exception {
113	jsr166	1.23	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	tim	1.1	public Object run() {
118			return TEST_STRING;
119	dl	1.5	}}));
120	tim	1.1
121	jsr166	1.23	assertSame(TEST_STRING, future.get());
122			}};
123
124			runWithPermissions(r);
125	tim	1.1	}
126
127			/**
128	dl	1.12	* A submitted failed privileged exception action reports exception
129	tim	1.1	*/
130	jsr166	1.19	public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
131	jsr166	1.23	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	tim	1.1	public Object run() throws Exception {
136			throw new IndexOutOfBoundsException();
137	dl	1.5	}}));
138	tim	1.1
139	jsr166	1.23	try {
140			future.get();
141			shouldThrow();
142			} catch (ExecutionException success) {
143			assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
144			}}};
145
146			runWithPermissions(r);
147	tim	1.1	}
148
149			/**
150	dl	1.12	* execute(null runnable) throws NPE
151	tim	1.1	*/
152			public void testExecuteNullRunnable() {
153			try {
154			ExecutorService e = new DirectExecutorService();
155	jsr166	1.19	e.submit((Runnable) null);
156	tim	1.1	shouldThrow();
157	jsr166	1.19	} catch (NullPointerException success) {}
158	tim	1.1	}
159
160
161			/**
162	dl	1.12	* submit(null callable) throws NPE
163	tim	1.1	*/
164	dl	1.6	public void testSubmitNullCallable() {
165	tim	1.1	try {
166			ExecutorService e = new DirectExecutorService();
167	jsr166	1.19	e.submit((Callable) null);
168	tim	1.1	shouldThrow();
169	jsr166	1.19	} catch (NullPointerException success) {}
170	tim	1.1	}
171
172			/**
173	dl	1.12	* submit(runnable) throws RejectedExecutionException if
174			* executor is saturated.
175	tim	1.1	*/
176			public void testExecute1() {
177	jsr166	1.19	ThreadPoolExecutor p =
178			new ThreadPoolExecutor(1, 1,
179			60, TimeUnit.SECONDS,
180			new ArrayBlockingQueue<Runnable>(1));
181	tim	1.1	try {
182	jsr166	1.19	for (int i = 0; i < 2; ++i)
183	dl	1.4	p.submit(new MediumRunnable());
184	jsr166	1.19	for (int i = 0; i < 2; ++i) {
185			try {
186			p.submit(new MediumRunnable());
187			shouldThrow();
188			} catch (RejectedExecutionException success) {}
189	tim	1.1	}
190	jsr166	1.19	} finally {
191			joinPool(p);
192			}
193	tim	1.1	}
194
195			/**
196	dl	1.12	* submit(callable) throws RejectedExecutionException
197			* if executor is saturated.
198	tim	1.1	*/
199			public void testExecute2() {
200	jsr166	1.19	ThreadPoolExecutor p =
201			new ThreadPoolExecutor(1, 1,
202			60, TimeUnit.SECONDS,
203			new ArrayBlockingQueue<Runnable>(1));
204	tim	1.1	try {
205	jsr166	1.19	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	tim	1.1	}
213	jsr166	1.19	} finally {
214			joinPool(p);
215			}
216	tim	1.1	}
217
218
219			/**
220	jsr166	1.25	* submit(callable).get() throws InterruptedException if interrupted
221	tim	1.1	*/
222	jsr166	1.19	public void testInterruptedSubmit() throws InterruptedException {
223	jsr166	1.25	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	tim	1.1	}
249
250			/**
251	jsr166	1.27	* get of submitted callable throws InterruptedException if callable
252			* interrupted
253	tim	1.1	*/
254	jsr166	1.19	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	tim	1.1	joinPool(p);
270			}
271
272			/**
273	jsr166	1.27	* get of submit(callable) throws ExecutionException if callable
274			* throws exception
275	tim	1.1	*/
276	jsr166	1.19	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	tim	1.1
285			try {
286	jsr166	1.19	p.submit(c).get();
287	tim	1.1	shouldThrow();
288	jsr166	1.19	} catch (ExecutionException success) {
289			assertTrue(success.getCause() instanceof ArithmeticException);
290	tim	1.1	}
291			joinPool(p);
292	dl	1.6	}
293
294			/**
295			* invokeAny(null) throws NPE
296			*/
297	jsr166	1.19	public void testInvokeAny1()
298			throws InterruptedException, ExecutionException {
299	dl	1.6	ExecutorService e = new DirectExecutorService();
300			try {
301			e.invokeAny(null);
302	jsr166	1.19	shouldThrow();
303	dl	1.6	} catch (NullPointerException success) {
304			} finally {
305			joinPool(e);
306			}
307			}
308
309			/**
310			* invokeAny(empty collection) throws IAE
311			*/
312	jsr166	1.19	public void testInvokeAny2()
313			throws InterruptedException, ExecutionException {
314	dl	1.6	ExecutorService e = new DirectExecutorService();
315			try {
316			e.invokeAny(new ArrayList<Callable<String>>());
317	jsr166	1.19	shouldThrow();
318	dl	1.6	} catch (IllegalArgumentException success) {
319			} finally {
320			joinPool(e);
321			}
322			}
323
324			/**
325			* invokeAny(c) throws NPE if c has null elements
326			*/
327	jsr166	1.19	public void testInvokeAny3() throws Exception {
328	dl	1.6	ExecutorService e = new DirectExecutorService();
329	jsr166	1.22	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	dl	1.6	try {
334			e.invokeAny(l);
335	jsr166	1.19	shouldThrow();
336	dl	1.6	} catch (NullPointerException success) {
337			} finally {
338			joinPool(e);
339			}
340			}
341
342			/**
343	dl	1.12	* invokeAny(c) throws ExecutionException if no task in c completes
344	dl	1.6	*/
345	jsr166	1.19	public void testInvokeAny4() throws InterruptedException {
346	dl	1.6	ExecutorService e = new DirectExecutorService();
347	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
348			l.add(new NPETask());
349	dl	1.6	try {
350	dl	1.8	e.invokeAny(l);
351	jsr166	1.19	shouldThrow();
352	jsr166	1.17	} catch (ExecutionException success) {
353	jsr166	1.19	assertTrue(success.getCause() instanceof NullPointerException);
354	dl	1.6	} finally {
355			joinPool(e);
356			}
357			}
358
359			/**
360	dl	1.12	* invokeAny(c) returns result of some task in c if at least one completes
361	dl	1.6	*/
362	jsr166	1.19	public void testInvokeAny5() throws Exception {
363	dl	1.6	ExecutorService e = new DirectExecutorService();
364			try {
365	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
366	dl	1.6	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	jsr166	1.19	public void testInvokeAll1() throws InterruptedException {
379	dl	1.6	ExecutorService e = new DirectExecutorService();
380			try {
381			e.invokeAll(null);
382	jsr166	1.19	shouldThrow();
383	dl	1.6	} catch (NullPointerException success) {
384			} finally {
385			joinPool(e);
386			}
387			}
388
389			/**
390			* invokeAll(empty collection) returns empty collection
391			*/
392	jsr166	1.19	public void testInvokeAll2() throws InterruptedException {
393	dl	1.6	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	jsr166	1.19	public void testInvokeAll3() throws InterruptedException {
406	dl	1.6	ExecutorService e = new DirectExecutorService();
407	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
408			l.add(new StringTask());
409			l.add(null);
410	dl	1.6	try {
411			e.invokeAll(l);
412	jsr166	1.19	shouldThrow();
413	dl	1.6	} catch (NullPointerException success) {
414			} finally {
415			joinPool(e);
416			}
417			}
418
419			/**
420	dl	1.12	* get of returned element of invokeAll(c) throws exception on failed task
421	dl	1.6	*/
422	jsr166	1.19	public void testInvokeAll4() throws Exception {
423	dl	1.6	ExecutorService e = new DirectExecutorService();
424			try {
425	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
426	dl	1.6	l.add(new NPETask());
427	jsr166	1.22	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	jsr166	1.19	}
435	dl	1.6	} finally {
436			joinPool(e);
437			}
438			}
439
440			/**
441	dl	1.12	* invokeAll(c) returns results of all completed tasks in c
442	dl	1.6	*/
443	jsr166	1.19	public void testInvokeAll5() throws Exception {
444	dl	1.6	ExecutorService e = new DirectExecutorService();
445			try {
446	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
447	dl	1.6	l.add(new StringTask());
448			l.add(new StringTask());
449	jsr166	1.22	List<Future<String>> futures = e.invokeAll(l);
450			assertEquals(2, futures.size());
451			for (Future<String> future : futures)
452	jsr166	1.19	assertSame(TEST_STRING, future.get());
453	dl	1.8	} finally {
454			joinPool(e);
455			}
456			}
457
458
459			/**
460			* timed invokeAny(null) throws NPE
461			*/
462	jsr166	1.19	public void testTimedInvokeAny1() throws Exception {
463	dl	1.8	ExecutorService e = new DirectExecutorService();
464			try {
465	jsr166	1.20	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
466	jsr166	1.19	shouldThrow();
467	dl	1.8	} catch (NullPointerException success) {
468			} finally {
469			joinPool(e);
470			}
471			}
472
473			/**
474	dl	1.12	* timed invokeAny(null time unit) throws NPE
475	dl	1.8	*/
476	jsr166	1.19	public void testTimedInvokeAnyNullTimeUnit() throws Exception {
477	dl	1.8	ExecutorService e = new DirectExecutorService();
478	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
479			l.add(new StringTask());
480	dl	1.8	try {
481			e.invokeAny(l, MEDIUM_DELAY_MS, null);
482	jsr166	1.19	shouldThrow();
483	dl	1.8	} catch (NullPointerException success) {
484			} finally {
485			joinPool(e);
486			}
487			}
488
489			/**
490			* timed invokeAny(empty collection) throws IAE
491			*/
492	jsr166	1.19	public void testTimedInvokeAny2() throws Exception {
493	dl	1.8	ExecutorService e = new DirectExecutorService();
494			try {
495	jsr166	1.20	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
496	jsr166	1.19	shouldThrow();
497	dl	1.8	} 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	jsr166	1.19	public void testTimedInvokeAny3() throws Exception {
507	dl	1.8	ExecutorService e = new DirectExecutorService();
508	jsr166	1.22	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	dl	1.8	try {
513	jsr166	1.20	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
514	jsr166	1.19	shouldThrow();
515	dl	1.8	} catch (NullPointerException success) {
516			} finally {
517			joinPool(e);
518			}
519			}
520
521			/**
522			* timed invokeAny(c) throws ExecutionException if no task completes
523			*/
524	jsr166	1.19	public void testTimedInvokeAny4() throws Exception {
525	dl	1.8	ExecutorService e = new DirectExecutorService();
526	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
527			l.add(new NPETask());
528	dl	1.8	try {
529	jsr166	1.20	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
530	jsr166	1.19	shouldThrow();
531	jsr166	1.17	} catch (ExecutionException success) {
532	jsr166	1.19	assertTrue(success.getCause() instanceof NullPointerException);
533	dl	1.8	} finally {
534			joinPool(e);
535			}
536			}
537
538			/**
539	dl	1.12	* timed invokeAny(c) returns result of some task in c
540	dl	1.8	*/
541	jsr166	1.19	public void testTimedInvokeAny5() throws Exception {
542	dl	1.8	ExecutorService e = new DirectExecutorService();
543			try {
544	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
545	dl	1.8	l.add(new StringTask());
546			l.add(new StringTask());
547	jsr166	1.20	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
548	dl	1.8	assertSame(TEST_STRING, result);
549			} finally {
550			joinPool(e);
551			}
552			}
553
554			/**
555			* timed invokeAll(null) throws NPE
556			*/
557	jsr166	1.19	public void testTimedInvokeAll1() throws InterruptedException {
558	dl	1.8	ExecutorService e = new DirectExecutorService();
559			try {
560	jsr166	1.20	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
561	jsr166	1.19	shouldThrow();
562	dl	1.8	} catch (NullPointerException success) {
563			} finally {
564			joinPool(e);
565			}
566			}
567
568			/**
569	dl	1.12	* timed invokeAll(null time unit) throws NPE
570	dl	1.8	*/
571	jsr166	1.19	public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
572	dl	1.8	ExecutorService e = new DirectExecutorService();
573	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
574			l.add(new StringTask());
575	dl	1.8	try {
576			e.invokeAll(l, MEDIUM_DELAY_MS, null);
577	jsr166	1.19	shouldThrow();
578	dl	1.8	} catch (NullPointerException success) {
579			} finally {
580			joinPool(e);
581			}
582			}
583
584			/**
585			* timed invokeAll(empty collection) returns empty collection
586			*/
587	jsr166	1.19	public void testTimedInvokeAll2() throws InterruptedException {
588	dl	1.8	ExecutorService e = new DirectExecutorService();
589			try {
590	jsr166	1.20	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
591	dl	1.8	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	jsr166	1.19	public void testTimedInvokeAll3() throws InterruptedException {
601	dl	1.8	ExecutorService e = new DirectExecutorService();
602	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
603			l.add(new StringTask());
604			l.add(null);
605	dl	1.8	try {
606	jsr166	1.20	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
607	jsr166	1.19	shouldThrow();
608	dl	1.8	} catch (NullPointerException success) {
609			} finally {
610			joinPool(e);
611			}
612			}
613
614			/**
615	dl	1.12	* get of returned element of invokeAll(c) throws exception on failed task
616	dl	1.8	*/
617	jsr166	1.19	public void testTimedInvokeAll4() throws Exception {
618	dl	1.8	ExecutorService e = new DirectExecutorService();
619			try {
620	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
621	dl	1.8	l.add(new NPETask());
622	jsr166	1.22	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	jsr166	1.19	}
631	dl	1.8	} finally {
632			joinPool(e);
633			}
634			}
635
636			/**
637	dl	1.12	* timed invokeAll(c) returns results of all completed tasks in c
638	dl	1.8	*/
639	jsr166	1.19	public void testTimedInvokeAll5() throws Exception {
640	dl	1.8	ExecutorService e = new DirectExecutorService();
641			try {
642	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
643	dl	1.8	l.add(new StringTask());
644			l.add(new StringTask());
645	jsr166	1.22	List<Future<String>> futures =
646			e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
647			assertEquals(2, futures.size());
648			for (Future<String> future : futures)
649	jsr166	1.19	assertSame(TEST_STRING, future.get());
650	dl	1.8	} finally {
651			joinPool(e);
652			}
653			}
654
655			/**
656	dl	1.12	* timed invokeAll cancels tasks not completed by timeout
657	dl	1.8	*/
658	jsr166	1.19	public void testTimedInvokeAll6() throws InterruptedException {
659	dl	1.9	ExecutorService e = new DirectExecutorService();
660	dl	1.8	try {
661	jsr166	1.22	List<Callable<String>> l = new ArrayList<Callable<String>>();
662	dl	1.8	l.add(new StringTask());
663	dl	1.11	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
664			l.add(new StringTask());
665	jsr166	1.22	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	dl	1.8	Future<String> f1 = it.next();
670			Future<String> f2 = it.next();
671	dl	1.11	Future<String> f3 = it.next();
672	dl	1.8	assertTrue(f1.isDone());
673			assertFalse(f1.isCancelled());
674			assertTrue(f2.isDone());
675	dl	1.11	assertTrue(f3.isDone());
676			assertTrue(f3.isCancelled());
677	dl	1.6	} finally {
678			joinPool(e);
679			}
680	tim	1.1	}
681
682	dl	1.3	}