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
#	Content
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	return new TestSuite(AbstractExecutorServiceTest.class);
21	}
22
23	/**
24	* A no-frills implementation of AbstractExecutorService, designed
25	* to test the submit methods only.
26	*/
27	static class DirectExecutorService extends AbstractExecutorService {
28	public void execute(Runnable r) { r.run(); }
29	public void shutdown() { shutdown = true; }
30	public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
31	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	Future<?> future = e.submit(task);
46	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	* completed submit of callable returns result
60	*/
61	public void testSubmitCallable() {
62	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	/**
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
113	/**
114	* submit of a privileged action runs it to completion
115	*/
116	public void testSubmitPrivilegedAction() {
117	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	Future future = e.submit(Executors.callable(new PrivilegedAction() {
125	public Object run() {
126	return TEST_STRING;
127	}}));
128
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	* submit of a privileged exception action runs it to completion
145	*/
146	public void testSubmitPrivilegedExceptionAction() {
147	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	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
155	public Object run() {
156	return TEST_STRING;
157	}}));
158
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	* submit of a failed privileged exception action reports exception
175	*/
176	public void testSubmitFailedPrivilegedExceptionAction() {
177	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	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
185	public Object run() throws Exception {
186	throw new IndexOutOfBoundsException();
187	}}));
188
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	Future<?> future = e.submit(task);
210	shouldThrow();
211	}
212	catch (NullPointerException success) {
213	}
214	catch (Exception ex) {
215	unexpectedException();
216	}
217	}
218
219
220	/**
221	* submit of a null callable throws NPE
222	*/
223	public void testSubmitNullCallable() {
224	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	* submit of Runnable throws RejectedExecutionException if
239	* saturated.
240	*/
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	p.submit(new MediumRunnable());
247	}
248	shouldThrow();
249	} catch(RejectedExecutionException success){}
250	joinPool(p);
251	}
252
253	/**
254	* Completed submit of Callable throws RejectedExecutionException
255	* 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	* blocking on submit of Callable throws InterruptedException if
271	* caller interrupted.
272	*/
273	public void testInterruptedSubmit() {
274	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	p.submit(new Callable<Object>() {
279	public Object call() {
280	try {
281	Thread.sleep(MEDIUM_DELAY_MS);
282	shouldThrow();
283	} catch(InterruptedException e){
284	}
285	return null;
286	}
287	}).get();
288	} 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	* get of submit of Callable throws Exception if callable
307	* interrupted
308	*/
309	public void testSubmitIE() {
310	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	p.submit(new SmallCallable()).get();
316	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	* completed submit of Callable throws ExecutionException if
347	* callable throws exception
348	*/
349	public void testSubmitEE() {
350	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	p.submit(c).get();
362	}
363
364	shouldThrow();
365	}
366	catch(ExecutionException success){
367	} catch(Exception e) {
368	unexpectedException();
369	}
370	joinPool(p);
371	}
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	}
548
549	}