ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.10 by dl, Sat Nov 1 18:37:02 2003 UTC vs.
Revision 1.22 by dl, Mon May 9 17:15:27 2005 UTC

#	Line 1 | Line 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.
2	>	* Written by Doug Lea with assistance from members of JCP JSR-166
3	>	* Expert Group and released to the public domain, as explained at
4	>	* http://creativecommons.org/licenses/publicdomain
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import java.util.concurrent.*;
10		import junit.framework.*;
11	<	import java.util.List;
11	>	import java.util.*;
12
13		public class ThreadPoolExecutorTest extends JSR166TestCase {
14		public static void main(String[] args) {
#	Line 35 | Line 36 | public class ThreadPoolExecutorTest exte
36		}
37		}
38
39	+	static class FailingThreadFactory implements ThreadFactory{
40	+	int calls = 0;
41	+	public Thread newThread(Runnable r){
42	+	if (++calls > 1) return null;
43	+	return new Thread(r);
44	+	}
45	+	}
46	+
47	+
48		/**
49		*  execute successfully executes a runnable
50		*/
#	Line 116 | Line 126 | public class ThreadPoolExecutorTest exte
126		unexpectedException();
127		}
128		assertEquals(1, p2.getCompletedTaskCount());
129	<	p2.shutdown();
129	>	try { p2.shutdown(); } catch(SecurityException ok) { return; }
130		joinPool(p2);
131		}
132
#	Line 146 | Line 156 | public class ThreadPoolExecutorTest exte
156		ThreadFactory tf = new SimpleThreadFactory();
157		ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler());
158		assertSame(tf, p.getThreadFactory());
149	–	p.shutdown();
159		joinPool(p);
160		}
161
#	Line 158 | Line 167 | public class ThreadPoolExecutorTest exte
167		ThreadFactory tf = new SimpleThreadFactory();
168		p.setThreadFactory(tf);
169		assertSame(tf, p.getThreadFactory());
161	–	p.shutdown();
170		joinPool(p);
171		}
172
#	Line 184 | Line 192 | public class ThreadPoolExecutorTest exte
192		RejectedExecutionHandler h = new NoOpREHandler();
193		ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h);
194		assertSame(h, p.getRejectedExecutionHandler());
187	–	p.shutdown();
195		joinPool(p);
196		}
197
#	Line 197 | Line 204 | public class ThreadPoolExecutorTest exte
204		RejectedExecutionHandler h = new NoOpREHandler();
205		p.setRejectedExecutionHandler(h);
206		assertSame(h, p.getRejectedExecutionHandler());
200	–	p.shutdown();
207		joinPool(p);
208		}
209
#	Line 280 | Line 286 | public class ThreadPoolExecutorTest exte
286
287		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
288		assertFalse(p1.isShutdown());
289	<	p1.shutdown();
289	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
290		assertTrue(p1.isShutdown());
291		joinPool(p1);
292		}
#	Line 295 | Line 301 | public class ThreadPoolExecutorTest exte
301		try {
302		p1.execute(new MediumRunnable());
303		} finally {
304	<	p1.shutdown();
304	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
305		}
306		try {
307		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 315 | Line 321 | public class ThreadPoolExecutorTest exte
321		p1.execute(new SmallRunnable());
322		assertFalse(p1.isTerminating());
323		} finally {
324	<	p1.shutdown();
324	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
325		}
326		try {
327		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 332 | Line 338 | public class ThreadPoolExecutorTest exte
338		public void testGetQueue() {
339		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
340		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
341	<	CancellableTask[] tasks = new CancellableTask[5];
341	>	FutureTask[] tasks = new FutureTask[5];
342		for(int i = 0; i < 5; i++){
343	<	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
343	>	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
344		p1.execute(tasks[i]);
345		}
346		try {
#	Line 343 | Line 349 | public class ThreadPoolExecutorTest exte
349		assertSame(q, wq);
350		assertFalse(wq.contains(tasks[0]));
351		assertTrue(wq.contains(tasks[4]));
352	+	for (int i = 1; i < 5; ++i)
353	+	tasks[i].cancel(true);
354		p1.shutdownNow();
355		} catch(Exception e) {
356		unexpectedException();
#	Line 357 | Line 365 | public class ThreadPoolExecutorTest exte
365		public void testRemove() {
366		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
367		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
368	<	CancellableTask[] tasks = new CancellableTask[5];
368	>	FutureTask[] tasks = new FutureTask[5];
369		for(int i = 0; i < 5; i++){
370	<	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
370	>	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
371		p1.execute(tasks[i]);
372		}
373		try {
#	Line 373 | Line 381 | public class ThreadPoolExecutorTest exte
381		assertTrue(q.contains(tasks[3]));
382		assertTrue(p1.remove(tasks[3]));
383		assertFalse(q.contains(tasks[3]));
376	–	p1.shutdownNow();
384		} catch(Exception e) {
385		unexpectedException();
386		} finally {
#	Line 386 | Line 393 | public class ThreadPoolExecutorTest exte
393		*/
394		public void testPurge() {
395		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
396	<	CancellableTask[] tasks = new CancellableTask[5];
396	>	FutureTask[] tasks = new FutureTask[5];
397		for(int i = 0; i < 5; i++){
398	<	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
398	>	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
399		p1.execute(tasks[i]);
400		}
401		tasks[4].cancel(true);
#	Line 396 | Line 403 | public class ThreadPoolExecutorTest exte
403		p1.purge();
404		long count = p1.getTaskCount();
405		assertTrue(count >= 2 && count < 5);
399	–	p1.shutdownNow();
406		joinPool(p1);
407		}
408
#	Line 411 | Line 417 | public class ThreadPoolExecutorTest exte
417		p1.execute(new MediumPossiblyInterruptedRunnable());
418		}
419		finally {
420	<	l = p1.shutdownNow();
420	>	try {
421	>	l = p1.shutdownNow();
422	>	} catch (SecurityException ok) { return; }
423	>
424		}
425		assertTrue(p1.isShutdown());
426		assertTrue(l.size() <= 4);
#	Line 772 | Line 781 | public class ThreadPoolExecutorTest exte
781		for(int i = 1; i < 5; ++i) {
782		assertTrue(tasks[i].done);
783		}
784	<	p.shutdownNow();
784	>	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
785		} catch(RejectedExecutionException ex){
786		unexpectedException();
787		} finally {
#	Line 799 | Line 808 | public class ThreadPoolExecutorTest exte
808		for(int i = 0; i < 5; ++i){
809		assertFalse(tasks[i].done);
810		}
811	<	p.shutdownNow();
811	>	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
812		} catch(RejectedExecutionException ex){
813		unexpectedException();
814		} finally {
#	Line 822 | Line 831 | public class ThreadPoolExecutorTest exte
831		p.execute(r3);
832		assertFalse(p.getQueue().contains(r2));
833		assertTrue(p.getQueue().contains(r3));
834	<	p.shutdownNow();
834	>	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
835		} catch(RejectedExecutionException ex){
836		unexpectedException();
837		} finally {
#	Line 836 | Line 845 | public class ThreadPoolExecutorTest exte
845		public void testRejectedExecutionExceptionOnShutdown() {
846		ThreadPoolExecutor tpe =
847		new ThreadPoolExecutor(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
848	<	tpe.shutdown();
848	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
849		try {
850		tpe.execute(new NoOpRunnable());
851		shouldThrow();
#	Line 852 | Line 861 | public class ThreadPoolExecutorTest exte
861		RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
862		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
863
864	<	p.shutdown();
864	>	try { p.shutdown(); } catch(SecurityException ok) { return; }
865		try {
866		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
867		p.execute(r);
#	Line 871 | Line 880 | public class ThreadPoolExecutorTest exte
880		RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
881		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
882
883	<	p.shutdown();
883	>	try { p.shutdown(); } catch(SecurityException ok) { return; }
884		try {
885		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
886		p.execute(r);
#	Line 891 | Line 900 | public class ThreadPoolExecutorTest exte
900		RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
901		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
902
903	<	p.shutdown();
903	>	try { p.shutdown(); } catch(SecurityException ok) { return; }
904		try {
905		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
906		p.execute(r);
#	Line 931 | Line 940 | public class ThreadPoolExecutorTest exte
940		shouldThrow();
941		} catch(IllegalArgumentException success){
942		} finally {
943	<	tpe.shutdown();
943	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
944		}
945		joinPool(tpe);
946		}
#	Line 950 | Line 959 | public class ThreadPoolExecutorTest exte
959		shouldThrow();
960		} catch(IllegalArgumentException success){
961		} finally {
962	<	tpe.shutdown();
962	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
963		}
964		joinPool(tpe);
965		}
#	Line 969 | Line 978 | public class ThreadPoolExecutorTest exte
978		shouldThrow();
979		} catch(IllegalArgumentException success){
980		} finally {
981	<	tpe.shutdown();
981	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
982		}
983		joinPool(tpe);
984		}
#	Line 990 | Line 999 | public class ThreadPoolExecutorTest exte
999		shouldThrow();
1000		} catch(IllegalArgumentException success){
1001		} finally {
1002	<	tpe.shutdown();
1002	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1003		}
1004		joinPool(tpe);
1005		}
#	Line 1000 | Line 1009 | public class ThreadPoolExecutorTest exte
1009		*/
1010		public void testTerminated() {
1011		ExtendedTPE tpe = new ExtendedTPE();
1012	<	tpe.shutdown();
1012	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1013		assertTrue(tpe.terminatedCalled);
1014		joinPool(tpe);
1015		}
#	Line 1017 | Line 1026 | public class ThreadPoolExecutorTest exte
1026		assertTrue(r.done);
1027		assertTrue(tpe.beforeCalled);
1028		assertTrue(tpe.afterCalled);
1029	<	tpe.shutdown();
1029	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1030		}
1031		catch(Exception ex) {
1032		unexpectedException();
#	Line 1025 | Line 1034 | public class ThreadPoolExecutorTest exte
1034		joinPool(tpe);
1035		}
1036		}
1037	+
1038	+	/**
1039	+	* completed submit of callable returns result
1040	+	*/
1041	+	public void testSubmitCallable() {
1042	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1043	+	try {
1044	+	Future<String> future = e.submit(new StringTask());
1045	+	String result = future.get();
1046	+	assertSame(TEST_STRING, result);
1047	+	}
1048	+	catch (ExecutionException ex) {
1049	+	unexpectedException();
1050	+	}
1051	+	catch (InterruptedException ex) {
1052	+	unexpectedException();
1053	+	} finally {
1054	+	joinPool(e);
1055	+	}
1056	+	}
1057	+
1058	+	/**
1059	+	* completed submit of runnable returns successfully
1060	+	*/
1061	+	public void testSubmitRunnable() {
1062	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1063	+	try {
1064	+	Future<?> future = e.submit(new NoOpRunnable());
1065	+	future.get();
1066	+	assertTrue(future.isDone());
1067	+	}
1068	+	catch (ExecutionException ex) {
1069	+	unexpectedException();
1070	+	}
1071	+	catch (InterruptedException ex) {
1072	+	unexpectedException();
1073	+	} finally {
1074	+	joinPool(e);
1075	+	}
1076	+	}
1077	+
1078	+	/**
1079	+	* completed submit of (runnable, result) returns result
1080	+	*/
1081	+	public void testSubmitRunnable2() {
1082	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1083	+	try {
1084	+	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
1085	+	String result = future.get();
1086	+	assertSame(TEST_STRING, result);
1087	+	}
1088	+	catch (ExecutionException ex) {
1089	+	unexpectedException();
1090	+	}
1091	+	catch (InterruptedException ex) {
1092	+	unexpectedException();
1093	+	} finally {
1094	+	joinPool(e);
1095	+	}
1096	+	}
1097	+
1098	+
1099	+
1100	+
1101	+
1102	+	/**
1103	+	* invokeAny(null) throws NPE
1104	+	*/
1105	+	public void testInvokeAny1() {
1106	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1107	+	try {
1108	+	e.invokeAny(null);
1109	+	} catch (NullPointerException success) {
1110	+	} catch(Exception ex) {
1111	+	unexpectedException();
1112	+	} finally {
1113	+	joinPool(e);
1114	+	}
1115	+	}
1116	+
1117	+	/**
1118	+	* invokeAny(empty collection) throws IAE
1119	+	*/
1120	+	public void testInvokeAny2() {
1121	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1122	+	try {
1123	+	e.invokeAny(new ArrayList<Callable<String>>());
1124	+	} catch (IllegalArgumentException success) {
1125	+	} catch(Exception ex) {
1126	+	unexpectedException();
1127	+	} finally {
1128	+	joinPool(e);
1129	+	}
1130	+	}
1131	+
1132	+	/**
1133	+	* invokeAny(c) throws NPE if c has null elements
1134	+	*/
1135	+	public void testInvokeAny3() {
1136	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1137	+	try {
1138	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1139	+	l.add(new StringTask());
1140	+	l.add(null);
1141	+	e.invokeAny(l);
1142	+	} catch (NullPointerException success) {
1143	+	} catch(Exception ex) {
1144	+	unexpectedException();
1145	+	} finally {
1146	+	joinPool(e);
1147	+	}
1148	+	}
1149	+
1150	+	/**
1151	+	* invokeAny(c) throws ExecutionException if no task completes
1152	+	*/
1153	+	public void testInvokeAny4() {
1154	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1155	+	try {
1156	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1157	+	l.add(new NPETask());
1158	+	e.invokeAny(l);
1159	+	} catch (ExecutionException success) {
1160	+	} catch(Exception ex) {
1161	+	unexpectedException();
1162	+	} finally {
1163	+	joinPool(e);
1164	+	}
1165	+	}
1166	+
1167	+	/**
1168	+	* invokeAny(c) returns result of some task
1169	+	*/
1170	+	public void testInvokeAny5() {
1171	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1172	+	try {
1173	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1174	+	l.add(new StringTask());
1175	+	l.add(new StringTask());
1176	+	String result = e.invokeAny(l);
1177	+	assertSame(TEST_STRING, result);
1178	+	} catch (ExecutionException success) {
1179	+	} catch(Exception ex) {
1180	+	unexpectedException();
1181	+	} finally {
1182	+	joinPool(e);
1183	+	}
1184	+	}
1185	+
1186	+	/**
1187	+	* invokeAll(null) throws NPE
1188	+	*/
1189	+	public void testInvokeAll1() {
1190	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1191	+	try {
1192	+	e.invokeAll(null);
1193	+	} catch (NullPointerException success) {
1194	+	} catch(Exception ex) {
1195	+	unexpectedException();
1196	+	} finally {
1197	+	joinPool(e);
1198	+	}
1199	+	}
1200	+
1201	+	/**
1202	+	* invokeAll(empty collection) returns empty collection
1203	+	*/
1204	+	public void testInvokeAll2() {
1205	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1206	+	try {
1207	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1208	+	assertTrue(r.isEmpty());
1209	+	} catch(Exception ex) {
1210	+	unexpectedException();
1211	+	} finally {
1212	+	joinPool(e);
1213	+	}
1214	+	}
1215	+
1216	+	/**
1217	+	* invokeAll(c) throws NPE if c has null elements
1218	+	*/
1219	+	public void testInvokeAll3() {
1220	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1221	+	try {
1222	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1223	+	l.add(new StringTask());
1224	+	l.add(null);
1225	+	e.invokeAll(l);
1226	+	} catch (NullPointerException success) {
1227	+	} catch(Exception ex) {
1228	+	unexpectedException();
1229	+	} finally {
1230	+	joinPool(e);
1231	+	}
1232	+	}
1233	+
1234	+	/**
1235	+	* get of element of invokeAll(c) throws exception on failed task
1236	+	*/
1237	+	public void testInvokeAll4() {
1238	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1239	+	try {
1240	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1241	+	l.add(new NPETask());
1242	+	List<Future<String>> result = e.invokeAll(l);
1243	+	assertEquals(1, result.size());
1244	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1245	+	it.next().get();
1246	+	} catch(ExecutionException success) {
1247	+	} catch(Exception ex) {
1248	+	unexpectedException();
1249	+	} finally {
1250	+	joinPool(e);
1251	+	}
1252	+	}
1253	+
1254	+	/**
1255	+	* invokeAll(c) returns results of all completed tasks
1256	+	*/
1257	+	public void testInvokeAll5() {
1258	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1259	+	try {
1260	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1261	+	l.add(new StringTask());
1262	+	l.add(new StringTask());
1263	+	List<Future<String>> result = e.invokeAll(l);
1264	+	assertEquals(2, result.size());
1265	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1266	+	assertSame(TEST_STRING, it.next().get());
1267	+	} catch (ExecutionException success) {
1268	+	} catch(Exception ex) {
1269	+	unexpectedException();
1270	+	} finally {
1271	+	joinPool(e);
1272	+	}
1273	+	}
1274	+
1275	+
1276	+
1277	+	/**
1278	+	* timed invokeAny(null) throws NPE
1279	+	*/
1280	+	public void testTimedInvokeAny1() {
1281	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1282	+	try {
1283	+	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1284	+	} catch (NullPointerException success) {
1285	+	} catch(Exception ex) {
1286	+	unexpectedException();
1287	+	} finally {
1288	+	joinPool(e);
1289	+	}
1290	+	}
1291	+
1292	+	/**
1293	+	* timed invokeAny(,,null) throws NPE
1294	+	*/
1295	+	public void testTimedInvokeAnyNullTimeUnit() {
1296	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1297	+	try {
1298	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1299	+	l.add(new StringTask());
1300	+	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1301	+	} catch (NullPointerException success) {
1302	+	} catch(Exception ex) {
1303	+	unexpectedException();
1304	+	} finally {
1305	+	joinPool(e);
1306	+	}
1307	+	}
1308	+
1309	+	/**
1310	+	* timed invokeAny(empty collection) throws IAE
1311	+	*/
1312	+	public void testTimedInvokeAny2() {
1313	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1314	+	try {
1315	+	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1316	+	} catch (IllegalArgumentException success) {
1317	+	} catch(Exception ex) {
1318	+	unexpectedException();
1319	+	} finally {
1320	+	joinPool(e);
1321	+	}
1322	+	}
1323	+
1324	+	/**
1325	+	* timed invokeAny(c) throws NPE if c has null elements
1326	+	*/
1327	+	public void testTimedInvokeAny3() {
1328	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1329	+	try {
1330	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1331	+	l.add(new StringTask());
1332	+	l.add(null);
1333	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1334	+	} catch (NullPointerException success) {
1335	+	} catch(Exception ex) {
1336	+	ex.printStackTrace();
1337	+	unexpectedException();
1338	+	} finally {
1339	+	joinPool(e);
1340	+	}
1341	+	}
1342	+
1343	+	/**
1344	+	* timed invokeAny(c) throws ExecutionException if no task completes
1345	+	*/
1346	+	public void testTimedInvokeAny4() {
1347	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1348	+	try {
1349	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1350	+	l.add(new NPETask());
1351	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1352	+	} catch(ExecutionException success) {
1353	+	} catch(Exception ex) {
1354	+	unexpectedException();
1355	+	} finally {
1356	+	joinPool(e);
1357	+	}
1358	+	}
1359	+
1360	+	/**
1361	+	* timed invokeAny(c) returns result of some task
1362	+	*/
1363	+	public void testTimedInvokeAny5() {
1364	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1365	+	try {
1366	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1367	+	l.add(new StringTask());
1368	+	l.add(new StringTask());
1369	+	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1370	+	assertSame(TEST_STRING, result);
1371	+	} catch (ExecutionException success) {
1372	+	} catch(Exception ex) {
1373	+	unexpectedException();
1374	+	} finally {
1375	+	joinPool(e);
1376	+	}
1377	+	}
1378	+
1379	+	/**
1380	+	* timed invokeAll(null) throws NPE
1381	+	*/
1382	+	public void testTimedInvokeAll1() {
1383	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1384	+	try {
1385	+	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1386	+	} catch (NullPointerException success) {
1387	+	} catch(Exception ex) {
1388	+	unexpectedException();
1389	+	} finally {
1390	+	joinPool(e);
1391	+	}
1392	+	}
1393	+
1394	+	/**
1395	+	* timed invokeAll(,,null) throws NPE
1396	+	*/
1397	+	public void testTimedInvokeAllNullTimeUnit() {
1398	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1399	+	try {
1400	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1401	+	l.add(new StringTask());
1402	+	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1403	+	} catch (NullPointerException success) {
1404	+	} catch(Exception ex) {
1405	+	unexpectedException();
1406	+	} finally {
1407	+	joinPool(e);
1408	+	}
1409	+	}
1410	+
1411	+	/**
1412	+	* timed invokeAll(empty collection) returns empty collection
1413	+	*/
1414	+	public void testTimedInvokeAll2() {
1415	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1416	+	try {
1417	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1418	+	assertTrue(r.isEmpty());
1419	+	} catch(Exception ex) {
1420	+	unexpectedException();
1421	+	} finally {
1422	+	joinPool(e);
1423	+	}
1424	+	}
1425	+
1426	+	/**
1427	+	* timed invokeAll(c) throws NPE if c has null elements
1428	+	*/
1429	+	public void testTimedInvokeAll3() {
1430	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1431	+	try {
1432	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1433	+	l.add(new StringTask());
1434	+	l.add(null);
1435	+	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1436	+	} catch (NullPointerException success) {
1437	+	} catch(Exception ex) {
1438	+	unexpectedException();
1439	+	} finally {
1440	+	joinPool(e);
1441	+	}
1442	+	}
1443	+
1444	+	/**
1445	+	* get of element of invokeAll(c) throws exception on failed task
1446	+	*/
1447	+	public void testTimedInvokeAll4() {
1448	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1449	+	try {
1450	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1451	+	l.add(new NPETask());
1452	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1453	+	assertEquals(1, result.size());
1454	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1455	+	it.next().get();
1456	+	} catch(ExecutionException success) {
1457	+	} catch(Exception ex) {
1458	+	unexpectedException();
1459	+	} finally {
1460	+	joinPool(e);
1461	+	}
1462	+	}
1463	+
1464	+	/**
1465	+	* timed invokeAll(c) returns results of all completed tasks
1466	+	*/
1467	+	public void testTimedInvokeAll5() {
1468	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1469	+	try {
1470	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1471	+	l.add(new StringTask());
1472	+	l.add(new StringTask());
1473	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1474	+	assertEquals(2, result.size());
1475	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1476	+	assertSame(TEST_STRING, it.next().get());
1477	+	} catch (ExecutionException success) {
1478	+	} catch(Exception ex) {
1479	+	unexpectedException();
1480	+	} finally {
1481	+	joinPool(e);
1482	+	}
1483	+	}
1484	+
1485	+	/**
1486	+	* timed invokeAll(c) cancels tasks not completed by timeout
1487	+	*/
1488	+	public void testTimedInvokeAll6() {
1489	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1490	+	try {
1491	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1492	+	l.add(new StringTask());
1493	+	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1494	+	l.add(new StringTask());
1495	+	List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1496	+	assertEquals(3, result.size());
1497	+	Iterator<Future<String>> it = result.iterator();
1498	+	Future<String> f1 = it.next();
1499	+	Future<String> f2 = it.next();
1500	+	Future<String> f3 = it.next();
1501	+	assertTrue(f1.isDone());
1502	+	assertTrue(f2.isDone());
1503	+	assertTrue(f3.isDone());
1504	+	assertFalse(f1.isCancelled());
1505	+	assertTrue(f2.isCancelled());
1506	+	} catch(Exception ex) {
1507	+	unexpectedException();
1508	+	} finally {
1509	+	joinPool(e);
1510	+	}
1511	+	}
1512	+
1513	+	/**
1514	+	* Execution continues if there is at least one thread even if
1515	+	* thread factory fails to create more
1516	+	*/
1517	+	public void testFailingThreadFactory() {
1518	+	ExecutorService e = new ThreadPoolExecutor(100, 100, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1519	+	try {
1520	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1521	+	for (int k = 0; k < 100; ++k) {
1522	+	e.execute(new NoOpRunnable());
1523	+	}
1524	+	Thread.sleep(LONG_DELAY_MS);
1525	+	} catch(Exception ex) {
1526	+	unexpectedException();
1527	+	} finally {
1528	+	joinPool(e);
1529	+	}
1530	+	}
1531	+
1532	+	/**
1533	+	* allowsCoreThreadTimeOut is by default false.
1534	+	*/
1535	+	public void testAllowsCoreThreadTimeOut() {
1536	+	ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1537	+	assertFalse(tpe.allowsCoreThreadTimeOut());
1538	+	joinPool(tpe);
1539	+	}
1540	+
1541	+	/**
1542	+	* allowCoreThreadTimeOut(true) causes idle threads to time out
1543	+	*/
1544	+	public void testAllowCoreThreadTimeOut_true() {
1545	+	ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1546	+	tpe.allowCoreThreadTimeOut(true);
1547	+	tpe.execute(new NoOpRunnable());
1548	+	try {
1549	+	Thread.sleep(MEDIUM_DELAY_MS);
1550	+	assertEquals(0, tpe.getPoolSize());
1551	+	} catch(InterruptedException e){
1552	+	unexpectedException();
1553	+	} finally {
1554	+	joinPool(tpe);
1555	+	}
1556	+	}
1557	+
1558	+	/**
1559	+	* allowCoreThreadTimeOut(false) causes idle threads not to time out
1560	+	*/
1561	+	public void testAllowCoreThreadTimeOut_false() {
1562	+	ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1563	+	tpe.allowCoreThreadTimeOut(false);
1564	+	tpe.execute(new NoOpRunnable());
1565	+	try {
1566	+	Thread.sleep(MEDIUM_DELAY_MS);
1567	+	assertTrue(tpe.getPoolSize() >= 1);
1568	+	} catch(InterruptedException e){
1569	+	unexpectedException();
1570	+	} finally {
1571	+	joinPool(tpe);
1572	+	}
1573	+	}
1574	+
1575		}

Diff Legend

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