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 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() {
        try {
            ExecutorService e = new DirectExecutorService();
            TrackedShortRunnable task = new TrackedShortRunnable();
            assertFalse(task.done);
            Future<?> future = e.submit(task);
            future.get();
            assertTrue(task.done);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }


    /**
     * Completed submit(callable) returns result
     */
    public void testSubmitCallable() {
        try {
            ExecutorService e = new DirectExecutorService();
            Future<String> future = e.submit(new StringTask());
            String result = future.get();
            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * Completed submit(runnable) returns successfully
     */
    public void testSubmitRunnable() {
        try {
            ExecutorService e = new DirectExecutorService();
            Future<?> future = e.submit(new NoOpRunnable());
            future.get();
            assertTrue(future.isDone());
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * Completed submit(runnable, result) returns result
     */
    public void testSubmitRunnable2() {
        try {
            ExecutorService e = new DirectExecutorService();
            Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
            String result = future.get();
            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }


    /**
     * A submitted privileged action to completion
     */
    public void testSubmitPrivilegedAction() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        try {
            ExecutorService e = new DirectExecutorService();
            Future future = e.submit(Executors.callable(new PrivilegedAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

            Object result = future.get();
            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * A submitted a privileged exception action runs to completion
     */
    public void testSubmitPrivilegedExceptionAction() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        try {
            ExecutorService e = new DirectExecutorService();
            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() {
                        return TEST_STRING;
                    }}));

            Object result = future.get();
            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * A submitted failed privileged exception action reports exception
     */
    public void testSubmitFailedPrivilegedExceptionAction() {
        Policy savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        try {
            ExecutorService e = new DirectExecutorService();
            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        throw new IndexOutOfBoundsException();
                    }}));

            Object result = future.get();
            shouldThrow();
        }
        catch (ExecutionException success) {
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
        finally {
            Policy.setPolicy(savedPolicy);
        }
    }

    /**
     * execute(null runnable) throws NPE
     */
    public void testExecuteNullRunnable() {
        try {
            ExecutorService e = new DirectExecutorService();
            TrackedShortRunnable task = null;
            Future<?> future = e.submit(task);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }


    /**
     * submit(null callable) throws NPE
     */
    public void testSubmitNullCallable() {
        try {
            ExecutorService e = new DirectExecutorService();
            StringTask t = null;
            Future<String> future = e.submit(t);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * 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 < 5; ++i){
                p.submit(new MediumRunnable());
            }
            shouldThrow();
        } catch(RejectedExecutionException success){}
        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 < 5; ++i) {
                p.submit(new SmallCallable());
            }
            shouldThrow();
        } catch(RejectedExecutionException e){}
        joinPool(p);
    }


    /**
     *  Blocking on submit(callable) throws InterruptedException if
     *  caller interrupted.
     */
    public void testInterruptedSubmit() {
        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        p.submit(new Callable<Object>() {
                                public Object call() {
                                    try {
                                        Thread.sleep(MEDIUM_DELAY_MS);
                                        shouldThrow();
                                    } catch(InterruptedException e){
                                    }
                                    return null;
                                }
                            }).get();
                    } catch(InterruptedException success){
                    } catch(Exception e) {
                        unexpectedException();
                    }

                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
        } catch(Exception e){
            unexpectedException();
        }
        joinPool(p);
    }

    /**
     *  get of submitted callable throws Exception if callable
     *  interrupted
     */
    public void testSubmitIE() {
        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));

        final Callable c = new Callable() {
                public Object call() {
                    try {
                        p.submit(new SmallCallable()).get();
                        shouldThrow();
                    } catch(InterruptedException e){}
                    catch(RejectedExecutionException e2){}
                    catch(ExecutionException e3){}
                    return Boolean.TRUE;
                }
            };


        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        c.call();
                    } catch(Exception e){}
                }
          });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException e){
            unexpectedException();
        }

        joinPool(p);
    }

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

        try {
            Callable c = new Callable() {
                    public Object call() {
                        int i = 5/0;
                        return Boolean.TRUE;
                    }
                };

            for(int i =0; i < 5; i++){
                p.submit(c).get();
            }

            shouldThrow();
        }
        catch(ExecutionException success){
        } catch(Exception e) {
            unexpectedException();
        }
        joinPool(p);
    }

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

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

    /**
     * invokeAny(c) throws NPE if c has null elements
     */
    public void testInvokeAny3() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(null);
            e.invokeAny(l);
        } catch (NullPointerException success) {
        } catch(Exception ex) {
            ex.printStackTrace();
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAny(c) throws ExecutionException if no task in c completes
     */
    public void testInvokeAny4() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            e.invokeAny(l);
        } catch(ExecutionException success) {
        } catch(Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

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

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

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

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

    /**
     * get of returned element of invokeAll(c) throws exception on failed task
     */
    public void testInvokeAll4() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            List<Future<String>> result = e.invokeAll(l);
            assertEquals(1, result.size());
            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) 
                it.next().get();
        } catch(ExecutionException success) {
        } catch(Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAll(c) returns results of all completed tasks in c
     */
    public void testInvokeAll5() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            List<Future<String>> result = e.invokeAll(l);
            assertEquals(2, result.size());
            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) 
                assertSame(TEST_STRING, it.next().get());
        } catch (ExecutionException success) {
        } catch(Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }


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

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

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

    /**
     * timed invokeAny(c) throws NPE if c has null elements
     */
    public void testTimedInvokeAny3() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(null);
            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
        } catch (NullPointerException success) {
        } catch(Exception ex) {
            ex.printStackTrace();
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

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

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

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

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

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

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

    /**
     * get of returned element of invokeAll(c) throws exception on failed task
     */
    public void testTimedInvokeAll4() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new NPETask());
            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
            assertEquals(1, result.size());
            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) 
                it.next().get();
        } catch(ExecutionException success) {
        } catch(Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll(c) returns results of all completed tasks in c
     */
    public void testTimedInvokeAll5() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
            l.add(new StringTask());
            l.add(new StringTask());
            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
            assertEquals(2, result.size());
            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) 
                assertSame(TEST_STRING, it.next().get());
        } catch (ExecutionException success) {
        } catch(Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * timed invokeAll cancels tasks not completed by timeout
     */
    public void testTimedInvokeAll6() {
        ExecutorService e = new DirectExecutorService();
        try {
            ArrayList<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>> result = e.invokeAll(l, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
            assertEquals(3, result.size());
            Iterator<Future<String>> it = result.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());
        } catch(Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

}
Revision:	1.14
Committed:	Thu Jan 15 14:51:33 2004 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.13:	+1 -1 lines
Log Message:	Fix timing granularities
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/licenses/publicdomain
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9
10	import junit.framework.*;
11	import java.util.*;
12	import java.util.concurrent.*;
13	import java.math.BigInteger;
14	import java.security.*;
15
16	public class AbstractExecutorServiceTest extends JSR166TestCase{
17	public static void main(String[] args) {
18	junit.textui.TestRunner.run (suite());
19	}
20	public static Test suite() {
21	return new TestSuite(AbstractExecutorServiceTest.class);
22	}
23
24	/**
25	* A no-frills implementation of AbstractExecutorService, designed
26	* to test the submit methods only.
27	*/
28	static class DirectExecutorService extends AbstractExecutorService {
29	public void execute(Runnable r) { r.run(); }
30	public void shutdown() { shutdown = true; }
31	public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
32	public boolean isShutdown() { return shutdown; }
33	public boolean isTerminated() { return isShutdown(); }
34	public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
35	private volatile boolean shutdown = false;
36	}
37
38	/**
39	* execute(runnable) runs it to completion
40	*/
41	public void testExecuteRunnable() {
42	try {
43	ExecutorService e = new DirectExecutorService();
44	TrackedShortRunnable task = new TrackedShortRunnable();
45	assertFalse(task.done);
46	Future<?> future = e.submit(task);
47	future.get();
48	assertTrue(task.done);
49	}
50	catch (ExecutionException ex) {
51	unexpectedException();
52	}
53	catch (InterruptedException ex) {
54	unexpectedException();
55	}
56	}
57
58
59	/**
60	* Completed submit(callable) returns result
61	*/
62	public void testSubmitCallable() {
63	try {
64	ExecutorService e = new DirectExecutorService();
65	Future<String> future = e.submit(new StringTask());
66	String result = future.get();
67	assertSame(TEST_STRING, result);
68	}
69	catch (ExecutionException ex) {
70	unexpectedException();
71	}
72	catch (InterruptedException ex) {
73	unexpectedException();
74	}
75	}
76
77	/**
78	* Completed submit(runnable) returns successfully
79	*/
80	public void testSubmitRunnable() {
81	try {
82	ExecutorService e = new DirectExecutorService();
83	Future<?> future = e.submit(new NoOpRunnable());
84	future.get();
85	assertTrue(future.isDone());
86	}
87	catch (ExecutionException ex) {
88	unexpectedException();
89	}
90	catch (InterruptedException ex) {
91	unexpectedException();
92	}
93	}
94
95	/**
96	* Completed submit(runnable, result) returns result
97	*/
98	public void testSubmitRunnable2() {
99	try {
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	catch (ExecutionException ex) {
106	unexpectedException();
107	}
108	catch (InterruptedException ex) {
109	unexpectedException();
110	}
111	}
112
113
114	/**
115	* A submitted privileged action to completion
116	*/
117	public void testSubmitPrivilegedAction() {
118	Policy savedPolicy = Policy.getPolicy();
119	AdjustablePolicy policy = new AdjustablePolicy();
120	policy.addPermission(new RuntimePermission("getContextClassLoader"));
121	policy.addPermission(new RuntimePermission("setContextClassLoader"));
122	Policy.setPolicy(policy);
123	try {
124	ExecutorService e = new DirectExecutorService();
125	Future future = e.submit(Executors.callable(new PrivilegedAction() {
126	public Object run() {
127	return TEST_STRING;
128	}}));
129
130	Object result = future.get();
131	assertSame(TEST_STRING, result);
132	}
133	catch (ExecutionException ex) {
134	unexpectedException();
135	}
136	catch (InterruptedException ex) {
137	unexpectedException();
138	}
139	finally {
140	Policy.setPolicy(savedPolicy);
141	}
142	}
143
144	/**
145	* A submitted a privileged exception action runs to completion
146	*/
147	public void testSubmitPrivilegedExceptionAction() {
148	Policy savedPolicy = Policy.getPolicy();
149	AdjustablePolicy policy = new AdjustablePolicy();
150	policy.addPermission(new RuntimePermission("getContextClassLoader"));
151	policy.addPermission(new RuntimePermission("setContextClassLoader"));
152	Policy.setPolicy(policy);
153	try {
154	ExecutorService e = new DirectExecutorService();
155	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
156	public Object run() {
157	return TEST_STRING;
158	}}));
159
160	Object result = future.get();
161	assertSame(TEST_STRING, result);
162	}
163	catch (ExecutionException ex) {
164	unexpectedException();
165	}
166	catch (InterruptedException ex) {
167	unexpectedException();
168	}
169	finally {
170	Policy.setPolicy(savedPolicy);
171	}
172	}
173
174	/**
175	* A submitted failed privileged exception action reports exception
176	*/
177	public void testSubmitFailedPrivilegedExceptionAction() {
178	Policy savedPolicy = Policy.getPolicy();
179	AdjustablePolicy policy = new AdjustablePolicy();
180	policy.addPermission(new RuntimePermission("getContextClassLoader"));
181	policy.addPermission(new RuntimePermission("setContextClassLoader"));
182	Policy.setPolicy(policy);
183	try {
184	ExecutorService e = new DirectExecutorService();
185	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
186	public Object run() throws Exception {
187	throw new IndexOutOfBoundsException();
188	}}));
189
190	Object result = future.get();
191	shouldThrow();
192	}
193	catch (ExecutionException success) {
194	}
195	catch (InterruptedException ex) {
196	unexpectedException();
197	}
198	finally {
199	Policy.setPolicy(savedPolicy);
200	}
201	}
202
203	/**
204	* execute(null runnable) throws NPE
205	*/
206	public void testExecuteNullRunnable() {
207	try {
208	ExecutorService e = new DirectExecutorService();
209	TrackedShortRunnable task = null;
210	Future<?> future = e.submit(task);
211	shouldThrow();
212	}
213	catch (NullPointerException success) {
214	}
215	catch (Exception ex) {
216	unexpectedException();
217	}
218	}
219
220
221	/**
222	* submit(null callable) throws NPE
223	*/
224	public void testSubmitNullCallable() {
225	try {
226	ExecutorService e = new DirectExecutorService();
227	StringTask t = null;
228	Future<String> future = e.submit(t);
229	shouldThrow();
230	}
231	catch (NullPointerException success) {
232	}
233	catch (Exception ex) {
234	unexpectedException();
235	}
236	}
237
238	/**
239	* submit(runnable) throws RejectedExecutionException if
240	* executor is saturated.
241	*/
242	public void testExecute1() {
243	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
244	try {
245
246	for(int i = 0; i < 5; ++i){
247	p.submit(new MediumRunnable());
248	}
249	shouldThrow();
250	} catch(RejectedExecutionException success){}
251	joinPool(p);
252	}
253
254	/**
255	* submit(callable) throws RejectedExecutionException
256	* if executor is saturated.
257	*/
258	public void testExecute2() {
259	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
260	try {
261	for(int i = 0; i < 5; ++i) {
262	p.submit(new SmallCallable());
263	}
264	shouldThrow();
265	} catch(RejectedExecutionException e){}
266	joinPool(p);
267	}
268
269
270	/**
271	* Blocking on submit(callable) throws InterruptedException if
272	* caller interrupted.
273	*/
274	public void testInterruptedSubmit() {
275	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
276	Thread t = new Thread(new Runnable() {
277	public void run() {
278	try {
279	p.submit(new Callable<Object>() {
280	public Object call() {
281	try {
282	Thread.sleep(MEDIUM_DELAY_MS);
283	shouldThrow();
284	} catch(InterruptedException e){
285	}
286	return null;
287	}
288	}).get();
289	} catch(InterruptedException success){
290	} catch(Exception e) {
291	unexpectedException();
292	}
293
294	}
295	});
296	try {
297	t.start();
298	Thread.sleep(SHORT_DELAY_MS);
299	t.interrupt();
300	} catch(Exception e){
301	unexpectedException();
302	}
303	joinPool(p);
304	}
305
306	/**
307	* get of submitted callable throws Exception if callable
308	* interrupted
309	*/
310	public void testSubmitIE() {
311	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
312
313	final Callable c = new Callable() {
314	public Object call() {
315	try {
316	p.submit(new SmallCallable()).get();
317	shouldThrow();
318	} catch(InterruptedException e){}
319	catch(RejectedExecutionException e2){}
320	catch(ExecutionException e3){}
321	return Boolean.TRUE;
322	}
323	};
324
325
326
327	Thread t = new Thread(new Runnable() {
328	public void run() {
329	try {
330	c.call();
331	} catch(Exception e){}
332	}
333	});
334	try {
335	t.start();
336	Thread.sleep(SHORT_DELAY_MS);
337	t.interrupt();
338	t.join();
339	} catch(InterruptedException e){
340	unexpectedException();
341	}
342
343	joinPool(p);
344	}
345
346	/**
347	* get of submit(callable) throws ExecutionException if callable
348	* throws exception
349	*/
350	public void testSubmitEE() {
351	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
352
353	try {
354	Callable c = new Callable() {
355	public Object call() {
356	int i = 5/0;
357	return Boolean.TRUE;
358	}
359	};
360
361	for(int i =0; i < 5; i++){
362	p.submit(c).get();
363	}
364
365	shouldThrow();
366	}
367	catch(ExecutionException success){
368	} catch(Exception e) {
369	unexpectedException();
370	}
371	joinPool(p);
372	}
373
374	/**
375	* invokeAny(null) throws NPE
376	*/
377	public void testInvokeAny1() {
378	ExecutorService e = new DirectExecutorService();
379	try {
380	e.invokeAny(null);
381	} catch (NullPointerException success) {
382	} catch(Exception ex) {
383	unexpectedException();
384	} finally {
385	joinPool(e);
386	}
387	}
388
389	/**
390	* invokeAny(empty collection) throws IAE
391	*/
392	public void testInvokeAny2() {
393	ExecutorService e = new DirectExecutorService();
394	try {
395	e.invokeAny(new ArrayList<Callable<String>>());
396	} catch (IllegalArgumentException success) {
397	} catch(Exception ex) {
398	unexpectedException();
399	} finally {
400	joinPool(e);
401	}
402	}
403
404	/**
405	* invokeAny(c) throws NPE if c has null elements
406	*/
407	public void testInvokeAny3() {
408	ExecutorService e = new DirectExecutorService();
409	try {
410	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
411	l.add(new StringTask());
412	l.add(null);
413	e.invokeAny(l);
414	} catch (NullPointerException success) {
415	} catch(Exception ex) {
416	ex.printStackTrace();
417	unexpectedException();
418	} finally {
419	joinPool(e);
420	}
421	}
422
423	/**
424	* invokeAny(c) throws ExecutionException if no task in c completes
425	*/
426	public void testInvokeAny4() {
427	ExecutorService e = new DirectExecutorService();
428	try {
429	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
430	l.add(new NPETask());
431	e.invokeAny(l);
432	} catch(ExecutionException success) {
433	} catch(Exception ex) {
434	unexpectedException();
435	} finally {
436	joinPool(e);
437	}
438	}
439
440	/**
441	* invokeAny(c) returns result of some task in c if at least one completes
442	*/
443	public void testInvokeAny5() {
444	ExecutorService e = new DirectExecutorService();
445	try {
446	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
447	l.add(new StringTask());
448	l.add(new StringTask());
449	String result = e.invokeAny(l);
450	assertSame(TEST_STRING, result);
451	} catch (ExecutionException success) {
452	} catch(Exception ex) {
453	unexpectedException();
454	} finally {
455	joinPool(e);
456	}
457	}
458
459	/**
460	* invokeAll(null) throws NPE
461	*/
462	public void testInvokeAll1() {
463	ExecutorService e = new DirectExecutorService();
464	try {
465	e.invokeAll(null);
466	} catch (NullPointerException success) {
467	} catch(Exception ex) {
468	unexpectedException();
469	} finally {
470	joinPool(e);
471	}
472	}
473
474	/**
475	* invokeAll(empty collection) returns empty collection
476	*/
477	public void testInvokeAll2() {
478	ExecutorService e = new DirectExecutorService();
479	try {
480	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
481	assertTrue(r.isEmpty());
482	} catch(Exception ex) {
483	unexpectedException();
484	} finally {
485	joinPool(e);
486	}
487	}
488
489	/**
490	* invokeAll(c) throws NPE if c has null elements
491	*/
492	public void testInvokeAll3() {
493	ExecutorService e = new DirectExecutorService();
494	try {
495	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
496	l.add(new StringTask());
497	l.add(null);
498	e.invokeAll(l);
499	} catch (NullPointerException success) {
500	} catch(Exception ex) {
501	unexpectedException();
502	} finally {
503	joinPool(e);
504	}
505	}
506
507	/**
508	* get of returned element of invokeAll(c) throws exception on failed task
509	*/
510	public void testInvokeAll4() {
511	ExecutorService e = new DirectExecutorService();
512	try {
513	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
514	l.add(new NPETask());
515	List<Future<String>> result = e.invokeAll(l);
516	assertEquals(1, result.size());
517	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
518	it.next().get();
519	} catch(ExecutionException success) {
520	} catch(Exception ex) {
521	unexpectedException();
522	} finally {
523	joinPool(e);
524	}
525	}
526
527	/**
528	* invokeAll(c) returns results of all completed tasks in c
529	*/
530	public void testInvokeAll5() {
531	ExecutorService e = new DirectExecutorService();
532	try {
533	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
534	l.add(new StringTask());
535	l.add(new StringTask());
536	List<Future<String>> result = e.invokeAll(l);
537	assertEquals(2, result.size());
538	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
539	assertSame(TEST_STRING, it.next().get());
540	} catch (ExecutionException success) {
541	} catch(Exception ex) {
542	unexpectedException();
543	} finally {
544	joinPool(e);
545	}
546	}
547
548
549	/**
550	* timed invokeAny(null) throws NPE
551	*/
552	public void testTimedInvokeAny1() {
553	ExecutorService e = new DirectExecutorService();
554	try {
555	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
556	} catch (NullPointerException success) {
557	} catch(Exception ex) {
558	unexpectedException();
559	} finally {
560	joinPool(e);
561	}
562	}
563
564	/**
565	* timed invokeAny(null time unit) throws NPE
566	*/
567	public void testTimedInvokeAnyNullTimeUnit() {
568	ExecutorService e = new DirectExecutorService();
569	try {
570	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
571	l.add(new StringTask());
572	e.invokeAny(l, MEDIUM_DELAY_MS, null);
573	} catch (NullPointerException success) {
574	} catch(Exception ex) {
575	unexpectedException();
576	} finally {
577	joinPool(e);
578	}
579	}
580
581	/**
582	* timed invokeAny(empty collection) throws IAE
583	*/
584	public void testTimedInvokeAny2() {
585	ExecutorService e = new DirectExecutorService();
586	try {
587	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
588	} catch (IllegalArgumentException success) {
589	} catch(Exception ex) {
590	unexpectedException();
591	} finally {
592	joinPool(e);
593	}
594	}
595
596	/**
597	* timed invokeAny(c) throws NPE if c has null elements
598	*/
599	public void testTimedInvokeAny3() {
600	ExecutorService e = new DirectExecutorService();
601	try {
602	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
603	l.add(new StringTask());
604	l.add(null);
605	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
606	} catch (NullPointerException success) {
607	} catch(Exception ex) {
608	ex.printStackTrace();
609	unexpectedException();
610	} finally {
611	joinPool(e);
612	}
613	}
614
615	/**
616	* timed invokeAny(c) throws ExecutionException if no task completes
617	*/
618	public void testTimedInvokeAny4() {
619	ExecutorService e = new DirectExecutorService();
620	try {
621	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
622	l.add(new NPETask());
623	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
624	} catch(ExecutionException success) {
625	} catch(Exception ex) {
626	unexpectedException();
627	} finally {
628	joinPool(e);
629	}
630	}
631
632	/**
633	* timed invokeAny(c) returns result of some task in c
634	*/
635	public void testTimedInvokeAny5() {
636	ExecutorService e = new DirectExecutorService();
637	try {
638	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
639	l.add(new StringTask());
640	l.add(new StringTask());
641	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
642	assertSame(TEST_STRING, result);
643	} catch (ExecutionException success) {
644	} catch(Exception ex) {
645	unexpectedException();
646	} finally {
647	joinPool(e);
648	}
649	}
650
651	/**
652	* timed invokeAll(null) throws NPE
653	*/
654	public void testTimedInvokeAll1() {
655	ExecutorService e = new DirectExecutorService();
656	try {
657	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
658	} catch (NullPointerException success) {
659	} catch(Exception ex) {
660	unexpectedException();
661	} finally {
662	joinPool(e);
663	}
664	}
665
666	/**
667	* timed invokeAll(null time unit) throws NPE
668	*/
669	public void testTimedInvokeAllNullTimeUnit() {
670	ExecutorService e = new DirectExecutorService();
671	try {
672	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
673	l.add(new StringTask());
674	e.invokeAll(l, MEDIUM_DELAY_MS, null);
675	} catch (NullPointerException success) {
676	} catch(Exception ex) {
677	unexpectedException();
678	} finally {
679	joinPool(e);
680	}
681	}
682
683	/**
684	* timed invokeAll(empty collection) returns empty collection
685	*/
686	public void testTimedInvokeAll2() {
687	ExecutorService e = new DirectExecutorService();
688	try {
689	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
690	assertTrue(r.isEmpty());
691	} catch(Exception ex) {
692	unexpectedException();
693	} finally {
694	joinPool(e);
695	}
696	}
697
698	/**
699	* timed invokeAll(c) throws NPE if c has null elements
700	*/
701	public void testTimedInvokeAll3() {
702	ExecutorService e = new DirectExecutorService();
703	try {
704	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
705	l.add(new StringTask());
706	l.add(null);
707	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
708	} catch (NullPointerException success) {
709	} catch(Exception ex) {
710	unexpectedException();
711	} finally {
712	joinPool(e);
713	}
714	}
715
716	/**
717	* get of returned element of invokeAll(c) throws exception on failed task
718	*/
719	public void testTimedInvokeAll4() {
720	ExecutorService e = new DirectExecutorService();
721	try {
722	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
723	l.add(new NPETask());
724	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
725	assertEquals(1, result.size());
726	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
727	it.next().get();
728	} catch(ExecutionException success) {
729	} catch(Exception ex) {
730	unexpectedException();
731	} finally {
732	joinPool(e);
733	}
734	}
735
736	/**
737	* timed invokeAll(c) returns results of all completed tasks in c
738	*/
739	public void testTimedInvokeAll5() {
740	ExecutorService e = new DirectExecutorService();
741	try {
742	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
743	l.add(new StringTask());
744	l.add(new StringTask());
745	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
746	assertEquals(2, result.size());
747	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
748	assertSame(TEST_STRING, it.next().get());
749	} catch (ExecutionException success) {
750	} catch(Exception ex) {
751	unexpectedException();
752	} finally {
753	joinPool(e);
754	}
755	}
756
757	/**
758	* timed invokeAll cancels tasks not completed by timeout
759	*/
760	public void testTimedInvokeAll6() {
761	ExecutorService e = new DirectExecutorService();
762	try {
763	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
764	l.add(new StringTask());
765	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
766	l.add(new StringTask());
767	List<Future<String>> result = e.invokeAll(l, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
768	assertEquals(3, result.size());
769	Iterator<Future<String>> it = result.iterator();
770	Future<String> f1 = it.next();
771	Future<String> f2 = it.next();
772	Future<String> f3 = it.next();
773	assertTrue(f1.isDone());
774	assertFalse(f1.isCancelled());
775	assertTrue(f2.isDone());
776	assertTrue(f3.isDone());
777	assertTrue(f3.isCancelled());
778	} catch(Exception ex) {
779	unexpectedException();
780	} finally {
781	joinPool(e);
782	}
783	}
784
785	}