ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ExecutorsTest.java

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents):
Revision 1.4 by dl, Sat Sep 20 18:20:07 2003 UTC vs.
Revision 1.9 by tim, Tue Dec 9 19:09:24 2003 UTC

#	Line 10 | Line 10 | 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 ExecutorsTest extends JSR166TestCase{
15	–
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run (suite());
18		}
19		public static Test suite() {
20	<	return new TestSuite(ExecutorsTest.class);
20	>	return new TestSuite(ExecutorsTest.class);
21		}
22
23		private static final String TEST_STRING = "a test string";
24
25	–	private static class MyTask implements Runnable {
26	–	public void run() { completed = true; }
27	–	public boolean isCompleted() { return completed; }
28	–	public void reset() { completed = false; }
29	–	private boolean completed = false;
30	–	}
31	–
25		private static class StringTask implements Callable<String> {
26		public String call() { return TEST_STRING; }
27		}
#	Line 79 | Line 72 | public class ExecutorsTest extends JSR16
72		}
73		};
74
75	+	/**
76	+	* A newCachedThreadPool can execute runnables
77	+	*/
78	+	public void testNewCachedThreadPool1() {
79	+	ExecutorService e = Executors.newCachedThreadPool();
80	+	e.execute(new NoOpRunnable());
81	+	e.execute(new NoOpRunnable());
82	+	e.execute(new NoOpRunnable());
83	+	e.shutdown();
84	+	}
85	+
86	+	/**
87	+	* A newCachedThreadPool with given ThreadFactory can execute runnables
88	+	*/
89	+	public void testNewCachedThreadPool2() {
90	+	ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
91	+	e.execute(new NoOpRunnable());
92	+	e.execute(new NoOpRunnable());
93	+	e.execute(new NoOpRunnable());
94	+	e.shutdown();
95	+	}
96	+
97	+	/**
98	+	* A newCachedThreadPool with null ThreadFactory throws NPE
99	+	*/
100	+	public void testNewCachedThreadPool3() {
101	+	try {
102	+	ExecutorService e = Executors.newCachedThreadPool(null);
103	+	shouldThrow();
104	+	}
105	+	catch(NullPointerException success) {
106	+	}
107	+	}
108	+
109	+
110	+	/**
111	+	* A new SingleThreadExecutor can execute runnables
112	+	*/
113	+	public void testNewSingleThreadExecutor1() {
114	+	ExecutorService e = Executors.newSingleThreadExecutor();
115	+	e.execute(new NoOpRunnable());
116	+	e.execute(new NoOpRunnable());
117	+	e.execute(new NoOpRunnable());
118	+	e.shutdown();
119	+	}
120	+
121	+	/**
122	+	* A new SingleThreadExecutor with given ThreadFactory can execute runnables
123	+	*/
124	+	public void testNewSingleThreadExecutor2() {
125	+	ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
126	+	e.execute(new NoOpRunnable());
127	+	e.execute(new NoOpRunnable());
128	+	e.execute(new NoOpRunnable());
129	+	e.shutdown();
130	+	}
131	+
132	+	/**
133	+	* A new SingleThreadExecutor with null ThreadFactory throws NPE
134	+	*/
135	+	public void testNewSingleThreadExecutor3() {
136	+	try {
137	+	ExecutorService e = Executors.newSingleThreadExecutor(null);
138	+	shouldThrow();
139	+	}
140	+	catch(NullPointerException success) {
141	+	}
142	+	}
143	+
144	+	/**
145	+	* A new newFixedThreadPool can execute runnables
146	+	*/
147	+	public void testNewFixedThreadPool1() {
148	+	ExecutorService e = Executors.newFixedThreadPool(2);
149	+	e.execute(new NoOpRunnable());
150	+	e.execute(new NoOpRunnable());
151	+	e.execute(new NoOpRunnable());
152	+	e.shutdown();
153	+	}
154	+
155	+	/**
156	+	* A new newFixedThreadPool with given ThreadFactory can execute runnables
157	+	*/
158	+	public void testNewFixedThreadPool2() {
159	+	ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
160	+	e.execute(new NoOpRunnable());
161	+	e.execute(new NoOpRunnable());
162	+	e.execute(new NoOpRunnable());
163	+	e.shutdown();
164	+	}
165	+
166	+	/**
167	+	* A new newFixedThreadPool with null ThreadFactory throws NPE
168	+	*/
169	+	public void testNewFixedThreadPool3() {
170	+	try {
171	+	ExecutorService e = Executors.newFixedThreadPool(2, null);
172	+	shouldThrow();
173	+	}
174	+	catch(NullPointerException success) {
175	+	}
176	+	}
177	+
178	+	/**
179	+	* A new newFixedThreadPool with 0 threads throws IAE
180	+	*/
181	+	public void testNewFixedThreadPool4() {
182	+	try {
183	+	ExecutorService e = Executors.newFixedThreadPool(0);
184	+	shouldThrow();
185	+	}
186	+	catch(IllegalArgumentException success) {
187	+	}
188	+	}
189	+
190	+	/**
191	+	* execute of runnable runs it to completion
192	+	*/
193	+	public void testExecuteRunnable() {
194	+	try {
195	+	Executor e = new DirectExecutor();
196	+	TrackedShortRunnable task = new TrackedShortRunnable();
197	+	assertFalse(task.done);
198	+	Future<?> future = Executors.execute(e, task);
199	+	future.get();
200	+	assertTrue(task.done);
201	+	}
202	+	catch (ExecutionException ex) {
203	+	unexpectedException();
204	+	}
205	+	catch (InterruptedException ex) {
206	+	unexpectedException();
207	+	}
208	+	}
209	+
210	+	/**
211	+	* invoke of a runnable runs it to completion
212	+	*/
213	+	public void testInvokeRunnable() {
214	+	try {
215	+	Executor e = new DirectExecutor();
216	+	TrackedShortRunnable task = new TrackedShortRunnable();
217	+	assertFalse(task.done);
218	+	Executors.invoke(e, task);
219	+	assertTrue(task.done);
220	+	}
221	+	catch (ExecutionException ex) {
222	+	unexpectedException();
223	+	}
224	+	catch (InterruptedException ex) {
225	+	unexpectedException();
226	+	}
227	+	}
228	+
229	+	/**
230	+	* execute of a callable runs it to completion
231	+	*/
232	+	public void testExecuteCallable() {
233	+	try {
234	+	Executor e = new DirectExecutor();
235	+	Future<String> future = Executors.execute(e, new StringTask());
236	+	String result = future.get();
237	+	assertSame(TEST_STRING, result);
238	+	}
239	+	catch (ExecutionException ex) {
240	+	unexpectedException();
241	+	}
242	+	catch (InterruptedException ex) {
243	+	unexpectedException();
244	+	}
245	+	}
246	+
247	+
248	+	/**
249	+	* execute of a privileged action runs it to completion
250	+	*/
251	+	public void testExecutePrivilegedAction() {
252	+	Policy savedPolicy = Policy.getPolicy();
253	+	AdjustablePolicy policy = new AdjustablePolicy();
254	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
255	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
256	+	Policy.setPolicy(policy);
257	+	try {
258	+	Executor e = new DirectExecutor();
259	+	Future future = Executors.execute(e, new PrivilegedAction() {
260	+	public Object run() {
261	+	return TEST_STRING;
262	+	}});
263	+
264	+	Object result = future.get();
265	+	assertSame(TEST_STRING, result);
266	+	}
267	+	catch (ExecutionException ex) {
268	+	unexpectedException();
269	+	}
270	+	catch (InterruptedException ex) {
271	+	unexpectedException();
272	+	}
273	+	finally {
274	+	Policy.setPolicy(savedPolicy);
275	+	}
276	+	}
277	+
278	+	/**
279	+	* execute of a privileged exception action runs it to completion
280	+	*/
281	+	public void testExecutePrivilegedExceptionAction() {
282	+	Policy savedPolicy = Policy.getPolicy();
283	+	AdjustablePolicy policy = new AdjustablePolicy();
284	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
285	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
286	+	Policy.setPolicy(policy);
287	+	try {
288	+	Executor e = new DirectExecutor();
289	+	Future future = Executors.execute(e, new PrivilegedExceptionAction() {
290	+	public Object run() {
291	+	return TEST_STRING;
292	+	}});
293	+
294	+	Object result = future.get();
295	+	assertSame(TEST_STRING, result);
296	+	}
297	+	catch (ExecutionException ex) {
298	+	unexpectedException();
299	+	}
300	+	catch (InterruptedException ex) {
301	+	unexpectedException();
302	+	}
303	+	finally {
304	+	Policy.setPolicy(savedPolicy);
305	+	}
306	+	}
307	+
308	+	/**
309	+	* execute of a failed privileged exception action reports exception
310	+	*/
311	+	public void testExecuteFailedPrivilegedExceptionAction() {
312	+	Policy savedPolicy = Policy.getPolicy();
313	+	AdjustablePolicy policy = new AdjustablePolicy();
314	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
315	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
316	+	Policy.setPolicy(policy);
317	+	try {
318	+	Executor e = new DirectExecutor();
319	+	Future future = Executors.execute(e, new PrivilegedExceptionAction() {
320	+	public Object run() throws Exception {
321	+	throw new IndexOutOfBoundsException();
322	+	}});
323	+
324	+	Object result = future.get();
325	+	shouldThrow();
326	+	}
327	+	catch (ExecutionException success) {
328	+	}
329	+	catch (InterruptedException ex) {
330	+	unexpectedException();
331	+	}
332	+	finally {
333	+	Policy.setPolicy(savedPolicy);
334	+	}
335	+	}
336	+
337	+	/**
338	+	* invoke of a collable runs it to completion
339	+	*/
340	+	public void testInvokeCallable() {
341	+	try {
342	+	Executor e = new DirectExecutor();
343	+	String result = Executors.invoke(e, new StringTask());
344	+
345	+	assertSame(TEST_STRING, result);
346	+	}
347	+	catch (ExecutionException ex) {
348	+	unexpectedException();
349	+	}
350	+	catch (InterruptedException ex) {
351	+	unexpectedException();
352	+	}
353	+	}
354	+
355	+	/**
356	+	* execute with null executor throws NPE
357	+	*/
358	+	public void testNullExecuteRunnable() {
359	+	try {
360	+	TrackedShortRunnable task = new TrackedShortRunnable();
361	+	assertFalse(task.done);
362	+	Future<?> future = Executors.execute(null, task);
363	+	shouldThrow();
364	+	}
365	+	catch (NullPointerException success) {
366	+	}
367	+	catch (Exception ex) {
368	+	unexpectedException();
369	+	}
370	+	}
371	+
372	+	/**
373	+	* execute with a null runnable throws NPE
374	+	*/
375	+	public void testExecuteNullRunnable() {
376	+	try {
377	+	Executor e = new DirectExecutor();
378	+	TrackedShortRunnable task = null;
379	+	Future<?> future = Executors.execute(e, task);
380	+	shouldThrow();
381	+	}
382	+	catch (NullPointerException success) {
383	+	}
384	+	catch (Exception ex) {
385	+	unexpectedException();
386	+	}
387	+	}
388	+
389	+	/**
390	+	* invoke of a null runnable throws NPE
391	+	*/
392	+	public void testInvokeNullRunnable() {
393	+	try {
394	+	Executor e = new DirectExecutor();
395	+	TrackedShortRunnable task = null;
396	+	Executors.invoke(e, task);
397	+	shouldThrow();
398	+	}
399	+	catch (NullPointerException success) {
400	+	}
401	+	catch (Exception ex) {
402	+	unexpectedException();
403	+	}
404	+	}
405	+
406	+	/**
407	+	* execute of a null callable throws NPE
408	+	*/
409	+	public void testExecuteNullCallable() {
410	+	try {
411	+	Executor e = new DirectExecutor();
412	+	StringTask t = null;
413	+	Future<String> future = Executors.execute(e, t);
414	+	shouldThrow();
415	+	}
416	+	catch (NullPointerException success) {
417	+	}
418	+	catch (Exception ex) {
419	+	unexpectedException();
420	+	}
421	+	}
422
423	+	/**
424	+	* invoke of a null callable throws NPE
425	+	*/
426	+	public void testInvokeNullCallable() {
427	+	try {
428	+	Executor e = new DirectExecutor();
429	+	StringTask t = null;
430	+	String result = Executors.invoke(e, t);
431	+	shouldThrow();
432	+	}
433	+	catch (NullPointerException success) {
434	+	}
435	+	catch (Exception ex) {
436	+	unexpectedException();
437	+	}
438	+	}
439
440		/**
441	<	*   execute(Executor, Runnable) will throw
442	<	*  RejectedExecutionException Attempting to execute a runnable on
87	<	*  a full ThreadPool will cause such an exception here, up to 5
88	<	*  runnables are attempted on a pool capable on handling one
89	<	*  until it throws an exception
441	>	*  execute(Executor, Runnable) throws RejectedExecutionException
442	>	*  if saturated.
443		*/
444		public void testExecute1() {
445		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
446		try {
447
448		for(int i = 0; i < 5; ++i){
449	<	Executors.execute(p, new MediumRunnable(), Boolean.TRUE);
449	>	Executors.execute(p, new MediumRunnable());
450		}
451		shouldThrow();
452		} catch(RejectedExecutionException success){}
#	Line 101 | Line 454 | public class ExecutorsTest extends JSR16
454		}
455
456		/**
457	<	*   execute(Executor, Callable) will throw
458	<	*  RejectedExecutionException Attempting to execute a callable on
106	<	*  a full ThreadPool will cause such an exception here, up to 5
107	<	*  runnables are attempted on a pool capable on handling one
108	<	*  until it throws an exception
457	>	*  execute(Executor, Callable)throws RejectedExecutionException
458	>	*  if saturated.
459		*/
460		public void testExecute2() {
461		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
#	Line 120 | Line 470 | public class ExecutorsTest extends JSR16
470
471
472		/**
473	<	*   invoke(Executor, Runnable) throws InterruptedException
474	<	*  A single use of invoke starts that will wait long enough
125	<	*  for the invoking thread to be interrupted
473	>	*  invoke(Executor, Runnable) throws InterruptedException if
474	>	*  caller interrupted.
475		*/
476	<	public void testInvoke2() {
476	>	public void testInterruptedInvoke() {
477		final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
478		Thread t = new Thread(new Runnable() {
479		public void run() {
#	Line 156 | Line 505 | public class ExecutorsTest extends JSR16
505		}
506
507		/**
508	<	*   invoke(Executor, Runnable) will throw
509	<	*  ExecutionException An ExecutionException occurs when the
161	<	*  underlying Runnable throws an exception, here the
162	<	*  DivideByZeroException will cause an ExecutionException
508	>	*  invoke(Executor, Runnable) throws ExecutionException if
509	>	*  runnable throws exception.
510		*/
511		public void testInvoke3() {
512		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
#	Line 185 | Line 532 | public class ExecutorsTest extends JSR16
532
533
534		/**
535	<	*   invoke(Executor, Callable) throws
536	<	*  InterruptedException A single use of invoke starts that will
190	<	*  wait long enough for the invoking thread to be interrupted
535	>	*  invoke(Executor, Callable) throws InterruptedException if
536	>	*  callable throws exception
537		*/
538		public void testInvoke5() {
539		final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
#	Line 226 | Line 572 | public class ExecutorsTest extends JSR16
572		}
573
574		/**
575	<	*   invoke(Executor, Callable) will throw ExecutionException
576	<	*  An ExecutionException occurs when the underlying Runnable throws
231	<	*  an exception, here the DivideByZeroException will cause an ExecutionException
575	>	*  invoke(Executor, Callable) will throw ExecutionException
576	>	*  if callable throws exception
577		*/
578		public void testInvoke6() {
579		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
#	Line 246 | Line 591 | public class ExecutorsTest extends JSR16
591		}
592
593		shouldThrow();
594	<	} catch(RejectedExecutionException e){}
595	<	catch(InterruptedException e2){}
596	<	catch(ExecutionException e3){}
252	<	joinPool(p);
253	<	}
254	<
255	<	/**
256	<	*
257	<	*/
258	<	public void testExecuteRunnable () {
259	<	try {
260	<	Executor e = new DirectExecutor();
261	<	MyTask task = new MyTask();
262	<	assertFalse(task.isCompleted());
263	<	Future<String> future = Executors.execute(e, task, TEST_STRING);
264	<	String result = future.get();
265	<	assertTrue(task.isCompleted());
266	<	assertSame(TEST_STRING, result);
267	<	}
268	<	catch (ExecutionException ex) {
269	<	unexpectedException();
270	<	}
271	<	catch (InterruptedException ex) {
272	<	unexpectedException();
273	<	}
274	<	}
275	<
276	<	/**
277	<	*
278	<	*/
279	<	public void testInvokeRunnable () {
280	<	try {
281	<	Executor e = new DirectExecutor();
282	<	MyTask task = new MyTask();
283	<	assertFalse(task.isCompleted());
284	<	Executors.invoke(e, task);
285	<	assertTrue(task.isCompleted());
286	<	}
287	<	catch (ExecutionException ex) {
288	<	unexpectedException();
289	<	}
290	<	catch (InterruptedException ex) {
291	<	unexpectedException();
292	<	}
293	<	}
294	<
295	<	/**
296	<	*
297	<	*/
298	<	public void testExecuteCallable () {
299	<	try {
300	<	Executor e = new DirectExecutor();
301	<	Future<String> future = Executors.execute(e, new StringTask());
302	<	String result = future.get();
303	<	assertSame(TEST_STRING, result);
304	<	}
305	<	catch (ExecutionException ex) {
306	<	unexpectedException();
307	<	}
308	<	catch (InterruptedException ex) {
594	>	}
595	>	catch(ExecutionException success){
596	>	} catch(Exception e) {
597		unexpectedException();
598		}
599	+	joinPool(p);
600		}
601
313	–	/**
314	–	*
315	–	*/
316	–	public void testInvokeCallable () {
317	–	try {
318	–	Executor e = new DirectExecutor();
319	–	String result = Executors.invoke(e, new StringTask());
602
321	–	assertSame(TEST_STRING, result);
322	–	}
323	–	catch (ExecutionException ex) {
324	–	unexpectedException();
325	–	}
326	–	catch (InterruptedException ex) {
327	–	unexpectedException();
328	–	}
329	–	}
603
604		/**
605		*  timeouts from execute will time out if they compute too long.
#	Line 369 | Line 642 | public class ExecutorsTest extends JSR16
642		}
643
644
645	+	/**
646	+	* ThreadPoolExecutor using defaultThreadFactory has
647	+	* specified group, priority, daemon status, and name
648	+	*/
649	+	public void testDefaultThreadFactory() {
650	+	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
651	+	Runnable r = new Runnable() {
652	+	public void run() {
653	+	Thread current = Thread.currentThread();
654	+	threadAssertTrue(!current.isDaemon());
655	+	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
656	+	ThreadGroup g = current.getThreadGroup();
657	+	SecurityManager s = System.getSecurityManager();
658	+	if (s != null)
659	+	threadAssertTrue(g == s.getThreadGroup());
660	+	else
661	+	threadAssertTrue(g == egroup);
662	+	String name = current.getName();
663	+	threadAssertTrue(name.endsWith("thread-1"));
664	+	}
665	+	};
666	+	ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
667	+
668	+	e.execute(r);
669	+	e.shutdown();
670	+	try {
671	+	Thread.sleep(SHORT_DELAY_MS);
672	+	} catch (Exception eX) {
673	+	unexpectedException();
674	+	} finally {
675	+	joinPool(e);
676	+	}
677	+	}
678
679	+	/**
680	+	* ThreadPoolExecutor using privilegedThreadFactory has
681	+	* specified group, priority, daemon status, name,
682	+	* access control context and context class loader
683	+	*/
684	+	public void testPrivilegedThreadFactory() {
685	+	Policy savedPolicy = Policy.getPolicy();
686	+	AdjustablePolicy policy = new AdjustablePolicy();
687	+	policy.addPermission(new RuntimePermission("getContextClassLoader"));
688	+	policy.addPermission(new RuntimePermission("setContextClassLoader"));
689	+	Policy.setPolicy(policy);
690	+	final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
691	+	final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
692	+	final AccessControlContext thisacc = AccessController.getContext();
693	+	Runnable r = new Runnable() {
694	+	public void run() {
695	+	Thread current = Thread.currentThread();
696	+	threadAssertTrue(!current.isDaemon());
697	+	threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
698	+	ThreadGroup g = current.getThreadGroup();
699	+	SecurityManager s = System.getSecurityManager();
700	+	if (s != null)
701	+	threadAssertTrue(g == s.getThreadGroup());
702	+	else
703	+	threadAssertTrue(g == egroup);
704	+	String name = current.getName();
705	+	threadAssertTrue(name.endsWith("thread-1"));
706	+	threadAssertTrue(thisccl == current.getContextClassLoader());
707	+	threadAssertTrue(thisacc.equals(AccessController.getContext()));
708	+	}
709	+	};
710	+	ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
711	+
712	+	Policy.setPolicy(savedPolicy);
713	+	e.execute(r);
714	+	e.shutdown();
715	+	try {
716	+	Thread.sleep(SHORT_DELAY_MS);
717	+	} catch (Exception ex) {
718	+	unexpectedException();
719	+	} finally {
720	+	joinPool(e);
721	+	}
722	+
723	+	}
724
725		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines