test/tck/AbstractExecutorServiceTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, 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 of 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 of 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 of 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 of (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();
        }
    }


    /**
     * submit of a privileged action runs it 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);
        }
    }

    /**
     * submit of a privileged exception action runs it 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);
        }
    }

    /**
     * submit of a 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 with a 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 of a 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 of Runnable throws RejectedExecutionException if
     * saturated.
     */
    public void testExecute1() {
        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
        try {

            for(int i = 0; i < 5; ++i){
                p.submit(new MediumRunnable());
            }
            shouldThrow();
        } catch(RejectedExecutionException success){}
        joinPool(p);
    }

    /**
     * Completed submit of Callable throws RejectedExecutionException
     *  if saturated.
     */
    public void testExecute2() {
         ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, 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 of Callable throws InterruptedException if
     *  caller interrupted.
     */
    public void testInterruptedSubmit() {
        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, 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 submit of Callable throws Exception if callable
     *  interrupted
     */
    public void testSubmitIE() {
        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, 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);
    }

    /**
     *  completed submit of Callable throws ExecutionException if
     *  callable throws exception
     */
    public void testSubmitEE() {
        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, 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) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * invokeAny(c) throws ExecutionException if no task completes
     */
    public void testInvokeAny4() {
        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);
        }
    }

    /**
     * invokeAny(c) returns result of some task
     */
    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 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
     */
    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);
        }
    }

}
Revision:	1.6
Committed:	Mon Dec 22 00:48:55 2003 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.5:	+239 -68 lines
Log Message:	Add and adjust tests reflecting API changes
#	User	Rev	Content
1	tim	1.1	/*
2			* Written by members of JCP JSR-166 Expert Group and released to the
3			* public domain. Use, modify, and redistribute this code in any way
4			* without acknowledgement. Other contributors include Andrew Wright,
5			* Jeffrey Hayes, Pat Fischer, Mike Judd.
6			*/
7
8
9			import junit.framework.*;
10			import java.util.*;
11			import java.util.concurrent.*;
12			import java.math.BigInteger;
13			import java.security.*;
14
15			public class AbstractExecutorServiceTest extends JSR166TestCase{
16			public static void main(String[] args) {
17			junit.textui.TestRunner.run (suite());
18			}
19			public static Test suite() {
20	dl	1.6	return new TestSuite(AbstractExecutorServiceTest.class);
21	tim	1.1	}
22
23			/**
24			* A no-frills implementation of AbstractExecutorService, designed
25	dl	1.6	* to test the submit methods only.
26	tim	1.1	*/
27			static class DirectExecutorService extends AbstractExecutorService {
28			public void execute(Runnable r) { r.run(); }
29			public void shutdown() { shutdown = true; }
30	tim	1.2	public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
31	tim	1.1	public boolean isShutdown() { return shutdown; }
32			public boolean isTerminated() { return isShutdown(); }
33			public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
34			private volatile boolean shutdown = false;
35			}
36
37			/**
38			* execute of runnable runs it to completion
39			*/
40			public void testExecuteRunnable() {
41			try {
42			ExecutorService e = new DirectExecutorService();
43			TrackedShortRunnable task = new TrackedShortRunnable();
44			assertFalse(task.done);
45	dl	1.4	Future<?> future = e.submit(task);
46	tim	1.1	future.get();
47			assertTrue(task.done);
48			}
49			catch (ExecutionException ex) {
50			unexpectedException();
51			}
52			catch (InterruptedException ex) {
53			unexpectedException();
54			}
55			}
56
57
58			/**
59	dl	1.6	* completed submit of callable returns result
60	tim	1.1	*/
61	dl	1.6	public void testSubmitCallable() {
62	tim	1.1	try {
63			ExecutorService e = new DirectExecutorService();
64			Future<String> future = e.submit(new StringTask());
65			String result = future.get();
66			assertSame(TEST_STRING, result);
67			}
68			catch (ExecutionException ex) {
69			unexpectedException();
70			}
71			catch (InterruptedException ex) {
72			unexpectedException();
73			}
74			}
75
76	dl	1.6	/**
77			* completed submit of runnable returns successfully
78			*/
79			public void testSubmitRunnable() {
80			try {
81			ExecutorService e = new DirectExecutorService();
82			Future<?> future = e.submit(new NoOpRunnable());
83			future.get();
84			assertTrue(future.isDone());
85			}
86			catch (ExecutionException ex) {
87			unexpectedException();
88			}
89			catch (InterruptedException ex) {
90			unexpectedException();
91			}
92			}
93
94			/**
95			* completed submit of (runnable, result) returns result
96			*/
97			public void testSubmitRunnable2() {
98			try {
99			ExecutorService e = new DirectExecutorService();
100			Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
101			String result = future.get();
102			assertSame(TEST_STRING, result);
103			}
104			catch (ExecutionException ex) {
105			unexpectedException();
106			}
107			catch (InterruptedException ex) {
108			unexpectedException();
109			}
110			}
111
112	tim	1.1
113			/**
114	dl	1.6	* submit of a privileged action runs it to completion
115	tim	1.1	*/
116	dl	1.6	public void testSubmitPrivilegedAction() {
117	tim	1.1	Policy savedPolicy = Policy.getPolicy();
118			AdjustablePolicy policy = new AdjustablePolicy();
119			policy.addPermission(new RuntimePermission("getContextClassLoader"));
120			policy.addPermission(new RuntimePermission("setContextClassLoader"));
121			Policy.setPolicy(policy);
122			try {
123			ExecutorService e = new DirectExecutorService();
124	dl	1.5	Future future = e.submit(Executors.callable(new PrivilegedAction() {
125	tim	1.1	public Object run() {
126			return TEST_STRING;
127	dl	1.5	}}));
128	tim	1.1
129			Object result = future.get();
130			assertSame(TEST_STRING, result);
131			}
132			catch (ExecutionException ex) {
133			unexpectedException();
134			}
135			catch (InterruptedException ex) {
136			unexpectedException();
137			}
138			finally {
139			Policy.setPolicy(savedPolicy);
140			}
141			}
142
143			/**
144	dl	1.6	* submit of a privileged exception action runs it to completion
145	tim	1.1	*/
146	dl	1.6	public void testSubmitPrivilegedExceptionAction() {
147	tim	1.1	Policy savedPolicy = Policy.getPolicy();
148			AdjustablePolicy policy = new AdjustablePolicy();
149			policy.addPermission(new RuntimePermission("getContextClassLoader"));
150			policy.addPermission(new RuntimePermission("setContextClassLoader"));
151			Policy.setPolicy(policy);
152			try {
153			ExecutorService e = new DirectExecutorService();
154	dl	1.5	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
155	tim	1.1	public Object run() {
156			return TEST_STRING;
157	dl	1.5	}}));
158	tim	1.1
159			Object result = future.get();
160			assertSame(TEST_STRING, result);
161			}
162			catch (ExecutionException ex) {
163			unexpectedException();
164			}
165			catch (InterruptedException ex) {
166			unexpectedException();
167			}
168			finally {
169			Policy.setPolicy(savedPolicy);
170			}
171			}
172
173			/**
174	dl	1.6	* submit of a failed privileged exception action reports exception
175	tim	1.1	*/
176	dl	1.6	public void testSubmitFailedPrivilegedExceptionAction() {
177	tim	1.1	Policy savedPolicy = Policy.getPolicy();
178			AdjustablePolicy policy = new AdjustablePolicy();
179			policy.addPermission(new RuntimePermission("getContextClassLoader"));
180			policy.addPermission(new RuntimePermission("setContextClassLoader"));
181			Policy.setPolicy(policy);
182			try {
183			ExecutorService e = new DirectExecutorService();
184	dl	1.5	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
185	tim	1.1	public Object run() throws Exception {
186			throw new IndexOutOfBoundsException();
187	dl	1.5	}}));
188	tim	1.1
189			Object result = future.get();
190			shouldThrow();
191			}
192			catch (ExecutionException success) {
193			}
194			catch (InterruptedException ex) {
195			unexpectedException();
196			}
197			finally {
198			Policy.setPolicy(savedPolicy);
199			}
200			}
201
202			/**
203			* execute with a null runnable throws NPE
204			*/
205			public void testExecuteNullRunnable() {
206			try {
207			ExecutorService e = new DirectExecutorService();
208			TrackedShortRunnable task = null;
209	dl	1.4	Future<?> future = e.submit(task);
210	tim	1.1	shouldThrow();
211			}
212			catch (NullPointerException success) {
213			}
214			catch (Exception ex) {
215			unexpectedException();
216			}
217			}
218
219
220			/**
221	dl	1.6	* submit of a null callable throws NPE
222	tim	1.1	*/
223	dl	1.6	public void testSubmitNullCallable() {
224	tim	1.1	try {
225			ExecutorService e = new DirectExecutorService();
226			StringTask t = null;
227			Future<String> future = e.submit(t);
228			shouldThrow();
229			}
230			catch (NullPointerException success) {
231			}
232			catch (Exception ex) {
233			unexpectedException();
234			}
235			}
236
237			/**
238	dl	1.6	* submit of Runnable throws RejectedExecutionException if
239			* saturated.
240	tim	1.1	*/
241			public void testExecute1() {
242			ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
243			try {
244
245			for(int i = 0; i < 5; ++i){
246	dl	1.4	p.submit(new MediumRunnable());
247	tim	1.1	}
248			shouldThrow();
249			} catch(RejectedExecutionException success){}
250			joinPool(p);
251			}
252
253			/**
254	dl	1.6	* Completed submit of Callable throws RejectedExecutionException
255	tim	1.1	* if saturated.
256			*/
257			public void testExecute2() {
258			ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
259			try {
260			for(int i = 0; i < 5; ++i) {
261			p.submit(new SmallCallable());
262			}
263			shouldThrow();
264			} catch(RejectedExecutionException e){}
265			joinPool(p);
266			}
267
268
269			/**
270	dl	1.6	* blocking on submit of Callable throws InterruptedException if
271	tim	1.1	* caller interrupted.
272			*/
273	dl	1.6	public void testInterruptedSubmit() {
274	tim	1.1	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
275			Thread t = new Thread(new Runnable() {
276			public void run() {
277			try {
278	dl	1.6	p.submit(new Callable<Object>() {
279	dl	1.4	public Object call() {
280	tim	1.1	try {
281			Thread.sleep(MEDIUM_DELAY_MS);
282			shouldThrow();
283			} catch(InterruptedException e){
284			}
285	dl	1.4	return null;
286	tim	1.1	}
287	dl	1.6	}).get();
288	tim	1.1	} catch(InterruptedException success){
289			} catch(Exception e) {
290			unexpectedException();
291			}
292
293			}
294			});
295			try {
296			t.start();
297			Thread.sleep(SHORT_DELAY_MS);
298			t.interrupt();
299			} catch(Exception e){
300			unexpectedException();
301			}
302			joinPool(p);
303			}
304
305			/**
306	dl	1.6	* get of submit of Callable throws Exception if callable
307			* interrupted
308	tim	1.1	*/
309	dl	1.6	public void testSubmitIE() {
310	tim	1.1	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
311
312			final Callable c = new Callable() {
313			public Object call() {
314			try {
315	dl	1.6	p.submit(new SmallCallable()).get();
316	tim	1.1	shouldThrow();
317			} catch(InterruptedException e){}
318			catch(RejectedExecutionException e2){}
319			catch(ExecutionException e3){}
320			return Boolean.TRUE;
321			}
322			};
323
324
325
326			Thread t = new Thread(new Runnable() {
327			public void run() {
328			try {
329			c.call();
330			} catch(Exception e){}
331			}
332			});
333			try {
334			t.start();
335			Thread.sleep(SHORT_DELAY_MS);
336			t.interrupt();
337			t.join();
338			} catch(InterruptedException e){
339			unexpectedException();
340			}
341
342			joinPool(p);
343			}
344
345			/**
346	dl	1.6	* completed submit of Callable throws ExecutionException if
347			* callable throws exception
348	tim	1.1	*/
349	dl	1.6	public void testSubmitEE() {
350	tim	1.1	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
351
352			try {
353			Callable c = new Callable() {
354			public Object call() {
355			int i = 5/0;
356			return Boolean.TRUE;
357			}
358			};
359
360			for(int i =0; i < 5; i++){
361	dl	1.6	p.submit(c).get();
362	tim	1.1	}
363
364			shouldThrow();
365			}
366			catch(ExecutionException success){
367			} catch(Exception e) {
368			unexpectedException();
369			}
370			joinPool(p);
371	dl	1.6	}
372
373			/**
374			* invokeAny(null) throws NPE
375			*/
376			public void testInvokeAny1() {
377			ExecutorService e = new DirectExecutorService();
378			try {
379			e.invokeAny(null);
380			} catch (NullPointerException success) {
381			} catch(Exception ex) {
382			unexpectedException();
383			} finally {
384			joinPool(e);
385			}
386			}
387
388			/**
389			* invokeAny(empty collection) throws IAE
390			*/
391			public void testInvokeAny2() {
392			ExecutorService e = new DirectExecutorService();
393			try {
394			e.invokeAny(new ArrayList<Callable<String>>());
395			} catch (IllegalArgumentException success) {
396			} catch(Exception ex) {
397			unexpectedException();
398			} finally {
399			joinPool(e);
400			}
401			}
402
403			/**
404			* invokeAny(c) throws NPE if c has null elements
405			*/
406			public void testInvokeAny3() {
407			ExecutorService e = new DirectExecutorService();
408			try {
409			ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
410			l.add(new StringTask());
411			l.add(null);
412			e.invokeAny(l);
413			} catch (NullPointerException success) {
414			} catch(Exception ex) {
415			unexpectedException();
416			} finally {
417			joinPool(e);
418			}
419			}
420
421			/**
422			* invokeAny(c) throws ExecutionException if no task completes
423			*/
424			public void testInvokeAny4() {
425			ExecutorService e = new DirectExecutorService();
426			try {
427			ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
428			l.add(new NPETask());
429			List<Future<String>> result = e.invokeAll(l);
430			assertEquals(1, result.size());
431			for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
432			it.next().get();
433			} catch(ExecutionException success) {
434			} catch(Exception ex) {
435			unexpectedException();
436			} finally {
437			joinPool(e);
438			}
439			}
440
441			/**
442			* invokeAny(c) returns result of some task
443			*/
444			public void testInvokeAny5() {
445			ExecutorService e = new DirectExecutorService();
446			try {
447			ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
448			l.add(new StringTask());
449			l.add(new StringTask());
450			String result = e.invokeAny(l);
451			assertSame(TEST_STRING, result);
452			} catch (ExecutionException success) {
453			} catch(Exception ex) {
454			unexpectedException();
455			} finally {
456			joinPool(e);
457			}
458			}
459
460			/**
461			* invokeAll(null) throws NPE
462			*/
463			public void testInvokeAll1() {
464			ExecutorService e = new DirectExecutorService();
465			try {
466			e.invokeAll(null);
467			} catch (NullPointerException success) {
468			} catch(Exception ex) {
469			unexpectedException();
470			} finally {
471			joinPool(e);
472			}
473			}
474
475			/**
476			* invokeAll(empty collection) returns empty collection
477			*/
478			public void testInvokeAll2() {
479			ExecutorService e = new DirectExecutorService();
480			try {
481			List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
482			assertTrue(r.isEmpty());
483			} catch(Exception ex) {
484			unexpectedException();
485			} finally {
486			joinPool(e);
487			}
488			}
489
490			/**
491			* invokeAll(c) throws NPE if c has null elements
492			*/
493			public void testInvokeAll3() {
494			ExecutorService e = new DirectExecutorService();
495			try {
496			ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
497			l.add(new StringTask());
498			l.add(null);
499			e.invokeAll(l);
500			} catch (NullPointerException success) {
501			} catch(Exception ex) {
502			unexpectedException();
503			} finally {
504			joinPool(e);
505			}
506			}
507
508			/**
509			* get of element of invokeAll(c) throws exception on failed task
510			*/
511			public void testInvokeAll4() {
512			ExecutorService e = new DirectExecutorService();
513			try {
514			ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
515			l.add(new NPETask());
516			List<Future<String>> result = e.invokeAll(l);
517			assertEquals(1, result.size());
518			for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
519			it.next().get();
520			} catch(ExecutionException success) {
521			} catch(Exception ex) {
522			unexpectedException();
523			} finally {
524			joinPool(e);
525			}
526			}
527
528			/**
529			* invokeAll(c) returns results of all completed tasks
530			*/
531			public void testInvokeAll5() {
532			ExecutorService e = new DirectExecutorService();
533			try {
534			ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
535			l.add(new StringTask());
536			l.add(new StringTask());
537			List<Future<String>> result = e.invokeAll(l);
538			assertEquals(2, result.size());
539			for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
540			assertSame(TEST_STRING, it.next().get());
541			} catch (ExecutionException success) {
542			} catch(Exception ex) {
543			unexpectedException();
544			} finally {
545			joinPool(e);
546			}
547	tim	1.1	}
548
549	dl	1.3	}