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(ExecutorsTest.class);
    }

    /** 
     * A no-frills implementation of AbstractExecutorService, designed
     * to test the submit/invoke 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;
    }

    private static final String TEST_STRING = "a test string";

    private static class StringTask implements Callable<String> {
        public String call() { return TEST_STRING; }
    }

    /**
     * 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();
        }
    }

    /**
     * invoke of a runnable runs it to completion
     */
    public void testInvokeRunnable() {
        try {
            ExecutorService e = new DirectExecutorService();
            TrackedShortRunnable task = new TrackedShortRunnable();
            assertFalse(task.done);
            e.invoke(task);
            assertTrue(task.done);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * execute of a callable runs it to completion
     */
    public void testExecuteCallable() {
        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();
        }
    }


    /**
     * execute of a privileged action runs it to completion
     */
    public void testExecutePrivilegedAction() {
        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(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);
        }
    }

    /**
     * execute of a privileged exception action runs it to completion
     */
    public void testExecutePrivilegedExceptionAction() {
        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(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);
        }
    }

    /**
     * execute of a failed privileged exception action reports exception
     */
    public void testExecuteFailedPrivilegedExceptionAction() {
        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(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);
        }
    }

    /**
     * invoke of a collable runs it to completion
     */
    public void testInvokeCallable() {
        try {
            ExecutorService e = new DirectExecutorService();
            String result = e.invoke(new StringTask());

            assertSame(TEST_STRING, result);
        }
        catch (ExecutionException ex) {
            unexpectedException();
        }
        catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * 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();
        }
    }

    /**
     * invoke of a null runnable throws NPE
     */
    public void testInvokeNullRunnable() {
        try {
            ExecutorService e = new DirectExecutorService();
            TrackedShortRunnable task = null;
            e.invoke(task);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

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

    /**
     * invoke of a null callable throws NPE
     */
    public void testInvokeNullCallable() {
        try {
            ExecutorService e = new DirectExecutorService();
            StringTask t = null;
            String result = e.invoke(t);
            shouldThrow();
        }
        catch (NullPointerException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     *  execute(Executor, 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);
    }

    /**
     *  execute(Executor, 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);
    }


    /**
     *  invoke(Executor, Runnable) throws InterruptedException if
     *  caller interrupted.
     */
    public void testInterruptedInvoke() {
        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.invoke(new Runnable() {
                                public void run() {
                                    try {
                                        Thread.sleep(MEDIUM_DELAY_MS);
                                        shouldThrow();
                                    } catch(InterruptedException e){
                                    }
                                }
                            });
                    } catch(InterruptedException success){
                    } catch(Exception e) {
                        unexpectedException();
                    }

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

    /**
     *  invoke(Executor, Runnable) throws ExecutionException if
     *  runnable throws exception.
     */
    public void testInvoke3() {
        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            Runnable r = new Runnable() {
                    public void run() {
                        int i = 5/0;
                    }
                };

            for(int i =0; i < 5; i++){
                p.invoke(r);
            }

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


    /**
     *  invoke(Executor, Callable) throws InterruptedException if
     *  callable throws exception
     */
    public void testInvoke5() {
        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.invoke(new SmallCallable());
                        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);
    }

    /**
     *  invoke(Executor, Callable) will throw ExecutionException
     *  if callable throws exception
     */
    public void testInvoke6() {
        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.invoke(c);
            }

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

}
Revision:	1.2
Committed:	Wed Dec 10 02:24:00 2003 UTC (20 years, 5 months ago) by tim
Branch:	MAIN
Changes since 1.1:	+1 -1 lines
Log Message:	Raw List returned by shutdownNow is really List<Runnable>.
#	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(ExecutorsTest.class);
21	}
22
23	/**
24	* A no-frills implementation of AbstractExecutorService, designed
25	* to test the submit/invoke 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	private static final String TEST_STRING = "a test string";
38
39	private static class StringTask implements Callable<String> {
40	public String call() { return TEST_STRING; }
41	}
42
43	/**
44	* execute of runnable runs it to completion
45	*/
46	public void testExecuteRunnable() {
47	try {
48	ExecutorService e = new DirectExecutorService();
49	TrackedShortRunnable task = new TrackedShortRunnable();
50	assertFalse(task.done);
51	Future<?> future = e.submit(task);
52	future.get();
53	assertTrue(task.done);
54	}
55	catch (ExecutionException ex) {
56	unexpectedException();
57	}
58	catch (InterruptedException ex) {
59	unexpectedException();
60	}
61	}
62
63	/**
64	* invoke of a runnable runs it to completion
65	*/
66	public void testInvokeRunnable() {
67	try {
68	ExecutorService e = new DirectExecutorService();
69	TrackedShortRunnable task = new TrackedShortRunnable();
70	assertFalse(task.done);
71	e.invoke(task);
72	assertTrue(task.done);
73	}
74	catch (ExecutionException ex) {
75	unexpectedException();
76	}
77	catch (InterruptedException ex) {
78	unexpectedException();
79	}
80	}
81
82	/**
83	* execute of a callable runs it to completion
84	*/
85	public void testExecuteCallable() {
86	try {
87	ExecutorService e = new DirectExecutorService();
88	Future<String> future = e.submit(new StringTask());
89	String result = future.get();
90	assertSame(TEST_STRING, result);
91	}
92	catch (ExecutionException ex) {
93	unexpectedException();
94	}
95	catch (InterruptedException ex) {
96	unexpectedException();
97	}
98	}
99
100
101	/**
102	* execute of a privileged action runs it to completion
103	*/
104	public void testExecutePrivilegedAction() {
105	Policy savedPolicy = Policy.getPolicy();
106	AdjustablePolicy policy = new AdjustablePolicy();
107	policy.addPermission(new RuntimePermission("getContextClassLoader"));
108	policy.addPermission(new RuntimePermission("setContextClassLoader"));
109	Policy.setPolicy(policy);
110	try {
111	ExecutorService e = new DirectExecutorService();
112	Future future = e.submit(new PrivilegedAction() {
113	public Object run() {
114	return TEST_STRING;
115	}});
116
117	Object result = future.get();
118	assertSame(TEST_STRING, result);
119	}
120	catch (ExecutionException ex) {
121	unexpectedException();
122	}
123	catch (InterruptedException ex) {
124	unexpectedException();
125	}
126	finally {
127	Policy.setPolicy(savedPolicy);
128	}
129	}
130
131	/**
132	* execute of a privileged exception action runs it to completion
133	*/
134	public void testExecutePrivilegedExceptionAction() {
135	Policy savedPolicy = Policy.getPolicy();
136	AdjustablePolicy policy = new AdjustablePolicy();
137	policy.addPermission(new RuntimePermission("getContextClassLoader"));
138	policy.addPermission(new RuntimePermission("setContextClassLoader"));
139	Policy.setPolicy(policy);
140	try {
141	ExecutorService e = new DirectExecutorService();
142	Future future = e.submit(new PrivilegedExceptionAction() {
143	public Object run() {
144	return TEST_STRING;
145	}});
146
147	Object result = future.get();
148	assertSame(TEST_STRING, result);
149	}
150	catch (ExecutionException ex) {
151	unexpectedException();
152	}
153	catch (InterruptedException ex) {
154	unexpectedException();
155	}
156	finally {
157	Policy.setPolicy(savedPolicy);
158	}
159	}
160
161	/**
162	* execute of a failed privileged exception action reports exception
163	*/
164	public void testExecuteFailedPrivilegedExceptionAction() {
165	Policy savedPolicy = Policy.getPolicy();
166	AdjustablePolicy policy = new AdjustablePolicy();
167	policy.addPermission(new RuntimePermission("getContextClassLoader"));
168	policy.addPermission(new RuntimePermission("setContextClassLoader"));
169	Policy.setPolicy(policy);
170	try {
171	ExecutorService e = new DirectExecutorService();
172	Future future = e.submit(new PrivilegedExceptionAction() {
173	public Object run() throws Exception {
174	throw new IndexOutOfBoundsException();
175	}});
176
177	Object result = future.get();
178	shouldThrow();
179	}
180	catch (ExecutionException success) {
181	}
182	catch (InterruptedException ex) {
183	unexpectedException();
184	}
185	finally {
186	Policy.setPolicy(savedPolicy);
187	}
188	}
189
190	/**
191	* invoke of a collable runs it to completion
192	*/
193	public void testInvokeCallable() {
194	try {
195	ExecutorService e = new DirectExecutorService();
196	String result = e.invoke(new StringTask());
197
198	assertSame(TEST_STRING, result);
199	}
200	catch (ExecutionException ex) {
201	unexpectedException();
202	}
203	catch (InterruptedException ex) {
204	unexpectedException();
205	}
206	}
207
208	/**
209	* execute with a null runnable throws NPE
210	*/
211	public void testExecuteNullRunnable() {
212	try {
213	ExecutorService e = new DirectExecutorService();
214	TrackedShortRunnable task = null;
215	Future<?> future = e.submit(task);
216	shouldThrow();
217	}
218	catch (NullPointerException success) {
219	}
220	catch (Exception ex) {
221	unexpectedException();
222	}
223	}
224
225	/**
226	* invoke of a null runnable throws NPE
227	*/
228	public void testInvokeNullRunnable() {
229	try {
230	ExecutorService e = new DirectExecutorService();
231	TrackedShortRunnable task = null;
232	e.invoke(task);
233	shouldThrow();
234	}
235	catch (NullPointerException success) {
236	}
237	catch (Exception ex) {
238	unexpectedException();
239	}
240	}
241
242	/**
243	* execute of a null callable throws NPE
244	*/
245	public void testExecuteNullCallable() {
246	try {
247	ExecutorService e = new DirectExecutorService();
248	StringTask t = null;
249	Future<String> future = e.submit(t);
250	shouldThrow();
251	}
252	catch (NullPointerException success) {
253	}
254	catch (Exception ex) {
255	unexpectedException();
256	}
257	}
258
259	/**
260	* invoke of a null callable throws NPE
261	*/
262	public void testInvokeNullCallable() {
263	try {
264	ExecutorService e = new DirectExecutorService();
265	StringTask t = null;
266	String result = e.invoke(t);
267	shouldThrow();
268	}
269	catch (NullPointerException success) {
270	}
271	catch (Exception ex) {
272	unexpectedException();
273	}
274	}
275
276	/**
277	* execute(Executor, Runnable) throws RejectedExecutionException
278	* if saturated.
279	*/
280	public void testExecute1() {
281	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
282	try {
283
284	for(int i = 0; i < 5; ++i){
285	p.submit(new MediumRunnable());
286	}
287	shouldThrow();
288	} catch(RejectedExecutionException success){}
289	joinPool(p);
290	}
291
292	/**
293	* execute(Executor, Callable)throws RejectedExecutionException
294	* if saturated.
295	*/
296	public void testExecute2() {
297	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
298	try {
299	for(int i = 0; i < 5; ++i) {
300	p.submit(new SmallCallable());
301	}
302	shouldThrow();
303	} catch(RejectedExecutionException e){}
304	joinPool(p);
305	}
306
307
308	/**
309	* invoke(Executor, Runnable) throws InterruptedException if
310	* caller interrupted.
311	*/
312	public void testInterruptedInvoke() {
313	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
314	Thread t = new Thread(new Runnable() {
315	public void run() {
316	try {
317	p.invoke(new Runnable() {
318	public void run() {
319	try {
320	Thread.sleep(MEDIUM_DELAY_MS);
321	shouldThrow();
322	} catch(InterruptedException e){
323	}
324	}
325	});
326	} catch(InterruptedException success){
327	} catch(Exception e) {
328	unexpectedException();
329	}
330
331	}
332	});
333	try {
334	t.start();
335	Thread.sleep(SHORT_DELAY_MS);
336	t.interrupt();
337	} catch(Exception e){
338	unexpectedException();
339	}
340	joinPool(p);
341	}
342
343	/**
344	* invoke(Executor, Runnable) throws ExecutionException if
345	* runnable throws exception.
346	*/
347	public void testInvoke3() {
348	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
349	try {
350	Runnable r = new Runnable() {
351	public void run() {
352	int i = 5/0;
353	}
354	};
355
356	for(int i =0; i < 5; i++){
357	p.invoke(r);
358	}
359
360	shouldThrow();
361	} catch(ExecutionException success){
362	} catch(Exception e){
363	unexpectedException();
364	}
365	joinPool(p);
366	}
367
368
369
370	/**
371	* invoke(Executor, Callable) throws InterruptedException if
372	* callable throws exception
373	*/
374	public void testInvoke5() {
375	final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
376
377	final Callable c = new Callable() {
378	public Object call() {
379	try {
380	p.invoke(new SmallCallable());
381	shouldThrow();
382	} catch(InterruptedException e){}
383	catch(RejectedExecutionException e2){}
384	catch(ExecutionException e3){}
385	return Boolean.TRUE;
386	}
387	};
388
389
390
391	Thread t = new Thread(new Runnable() {
392	public void run() {
393	try {
394	c.call();
395	} catch(Exception e){}
396	}
397	});
398	try {
399	t.start();
400	Thread.sleep(SHORT_DELAY_MS);
401	t.interrupt();
402	t.join();
403	} catch(InterruptedException e){
404	unexpectedException();
405	}
406
407	joinPool(p);
408	}
409
410	/**
411	* invoke(Executor, Callable) will throw ExecutionException
412	* if callable throws exception
413	*/
414	public void testInvoke6() {
415	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
416
417	try {
418	Callable c = new Callable() {
419	public Object call() {
420	int i = 5/0;
421	return Boolean.TRUE;
422	}
423	};
424
425	for(int i =0; i < 5; i++){
426	p.invoke(c);
427	}
428
429	shouldThrow();
430	}
431	catch(ExecutionException success){
432	} catch(Exception e) {
433	unexpectedException();
434	}
435	joinPool(p);
436	}
437
438	}