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


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

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

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

    /**
     * invoke of a callable 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();
        }
    }


    /**
     * 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, Callable) 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 Callable<Object>() {
                                public Object call() {
                                    try {
                                        Thread.sleep(MEDIUM_DELAY_MS);
                                        shouldThrow();
                                    } catch(InterruptedException e){
                                    }
                                    return null;
                                }
                            });
                    } 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, 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.5
Committed:	Fri Dec 19 20:42:44 2003 UTC (20 years, 5 months ago) by dl
Branch:	MAIN
Changes since 1.4:	+6 -6 lines
Log Message:	Use callables for PrivilegedActions
#	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			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	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			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	dl	1.4	Future<?> future = e.submit(task);
52	tim	1.1	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			/**
65			* execute of a callable runs it to completion
66			*/
67			public void testExecuteCallable() {
68			try {
69			ExecutorService e = new DirectExecutorService();
70			Future<String> future = e.submit(new StringTask());
71			String result = future.get();
72			assertSame(TEST_STRING, result);
73			}
74			catch (ExecutionException ex) {
75			unexpectedException();
76			}
77			catch (InterruptedException ex) {
78			unexpectedException();
79			}
80			}
81
82
83			/**
84			* execute of a privileged action runs it to completion
85			*/
86			public void testExecutePrivilegedAction() {
87			Policy savedPolicy = Policy.getPolicy();
88			AdjustablePolicy policy = new AdjustablePolicy();
89			policy.addPermission(new RuntimePermission("getContextClassLoader"));
90			policy.addPermission(new RuntimePermission("setContextClassLoader"));
91			Policy.setPolicy(policy);
92			try {
93			ExecutorService e = new DirectExecutorService();
94	dl	1.5	Future future = e.submit(Executors.callable(new PrivilegedAction() {
95	tim	1.1	public Object run() {
96			return TEST_STRING;
97	dl	1.5	}}));
98	tim	1.1
99			Object result = future.get();
100			assertSame(TEST_STRING, result);
101			}
102			catch (ExecutionException ex) {
103			unexpectedException();
104			}
105			catch (InterruptedException ex) {
106			unexpectedException();
107			}
108			finally {
109			Policy.setPolicy(savedPolicy);
110			}
111			}
112
113			/**
114			* execute of a privileged exception action runs it to completion
115			*/
116			public void testExecutePrivilegedExceptionAction() {
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	dl	1.5	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
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			* execute of a failed privileged exception action reports exception
145			*/
146			public void testExecuteFailedPrivilegedExceptionAction() {
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	dl	1.5	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
155	tim	1.1	public Object run() throws Exception {
156			throw new IndexOutOfBoundsException();
157	dl	1.5	}}));
158	tim	1.1
159			Object result = future.get();
160			shouldThrow();
161			}
162			catch (ExecutionException success) {
163			}
164			catch (InterruptedException ex) {
165			unexpectedException();
166			}
167			finally {
168			Policy.setPolicy(savedPolicy);
169			}
170			}
171
172			/**
173	dl	1.4	* invoke of a callable runs it to completion
174	tim	1.1	*/
175			public void testInvokeCallable() {
176			try {
177			ExecutorService e = new DirectExecutorService();
178			String result = e.invoke(new StringTask());
179
180			assertSame(TEST_STRING, result);
181			}
182			catch (ExecutionException ex) {
183			unexpectedException();
184			}
185			catch (InterruptedException ex) {
186			unexpectedException();
187			}
188			}
189
190			/**
191			* execute with a null runnable throws NPE
192			*/
193			public void testExecuteNullRunnable() {
194			try {
195			ExecutorService e = new DirectExecutorService();
196			TrackedShortRunnable task = null;
197	dl	1.4	Future<?> future = e.submit(task);
198	tim	1.1	shouldThrow();
199			}
200			catch (NullPointerException success) {
201			}
202			catch (Exception ex) {
203			unexpectedException();
204			}
205			}
206
207
208			/**
209			* execute of a null callable throws NPE
210			*/
211			public void testExecuteNullCallable() {
212			try {
213			ExecutorService e = new DirectExecutorService();
214			StringTask t = null;
215			Future<String> future = e.submit(t);
216			shouldThrow();
217			}
218			catch (NullPointerException success) {
219			}
220			catch (Exception ex) {
221			unexpectedException();
222			}
223			}
224
225			/**
226			* invoke of a null callable throws NPE
227			*/
228			public void testInvokeNullCallable() {
229			try {
230			ExecutorService e = new DirectExecutorService();
231			StringTask t = null;
232			String result = e.invoke(t);
233			shouldThrow();
234			}
235			catch (NullPointerException success) {
236			}
237			catch (Exception ex) {
238			unexpectedException();
239			}
240			}
241
242			/**
243			* execute(Executor, Runnable) throws RejectedExecutionException
244			* if saturated.
245			*/
246			public void testExecute1() {
247			ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
248			try {
249
250			for(int i = 0; i < 5; ++i){
251	dl	1.4	p.submit(new MediumRunnable());
252	tim	1.1	}
253			shouldThrow();
254			} catch(RejectedExecutionException success){}
255			joinPool(p);
256			}
257
258			/**
259			* execute(Executor, Callable)throws RejectedExecutionException
260			* if saturated.
261			*/
262			public void testExecute2() {
263			ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
264			try {
265			for(int i = 0; i < 5; ++i) {
266			p.submit(new SmallCallable());
267			}
268			shouldThrow();
269			} catch(RejectedExecutionException e){}
270			joinPool(p);
271			}
272
273
274			/**
275	dl	1.4	* invoke(Executor, Callable) throws InterruptedException if
276	tim	1.1	* caller interrupted.
277			*/
278			public void testInterruptedInvoke() {
279			final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
280			Thread t = new Thread(new Runnable() {
281			public void run() {
282			try {
283	dl	1.4	p.invoke(new Callable<Object>() {
284			public Object call() {
285	tim	1.1	try {
286			Thread.sleep(MEDIUM_DELAY_MS);
287			shouldThrow();
288			} catch(InterruptedException e){
289			}
290	dl	1.4	return null;
291	tim	1.1	}
292			});
293			} catch(InterruptedException success){
294			} catch(Exception e) {
295			unexpectedException();
296			}
297
298			}
299			});
300			try {
301			t.start();
302			Thread.sleep(SHORT_DELAY_MS);
303			t.interrupt();
304			} catch(Exception e){
305			unexpectedException();
306			}
307			joinPool(p);
308			}
309
310			/**
311			* invoke(Executor, Callable) throws InterruptedException if
312			* callable throws exception
313			*/
314			public void testInvoke5() {
315			final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
316
317			final Callable c = new Callable() {
318			public Object call() {
319			try {
320			p.invoke(new SmallCallable());
321			shouldThrow();
322			} catch(InterruptedException e){}
323			catch(RejectedExecutionException e2){}
324			catch(ExecutionException e3){}
325			return Boolean.TRUE;
326			}
327			};
328
329
330
331			Thread t = new Thread(new Runnable() {
332			public void run() {
333			try {
334			c.call();
335			} catch(Exception e){}
336			}
337			});
338			try {
339			t.start();
340			Thread.sleep(SHORT_DELAY_MS);
341			t.interrupt();
342			t.join();
343			} catch(InterruptedException e){
344			unexpectedException();
345			}
346
347			joinPool(p);
348			}
349
350			/**
351			* invoke(Executor, Callable) will throw ExecutionException
352			* if callable throws exception
353			*/
354			public void testInvoke6() {
355			ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
356
357			try {
358			Callable c = new Callable() {
359			public Object call() {
360			int i = 5/0;
361			return Boolean.TRUE;
362			}
363			};
364
365			for(int i =0; i < 5; i++){
366			p.invoke(c);
367			}
368
369			shouldThrow();
370			}
371			catch(ExecutionException success){
372			} catch(Exception e) {
373			unexpectedException();
374			}
375			joinPool(p);
376			}
377
378	dl	1.3	}