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.17 by dl, Tue Jan 20 20:20:56 2004 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 116 | Line 117 | public class ThreadPoolExecutorTest exte
117		unexpectedException();
118		}
119		assertEquals(1, p2.getCompletedTaskCount());
120	<	p2.shutdown();
120	>	try { p2.shutdown(); } catch(SecurityException ok) { return; }
121		joinPool(p2);
122		}
123
#	Line 146 | Line 147 | public class ThreadPoolExecutorTest exte
147		ThreadFactory tf = new SimpleThreadFactory();
148		ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler());
149		assertSame(tf, p.getThreadFactory());
149	–	p.shutdown();
150		joinPool(p);
151		}
152
#	Line 158 | Line 158 | public class ThreadPoolExecutorTest exte
158		ThreadFactory tf = new SimpleThreadFactory();
159		p.setThreadFactory(tf);
160		assertSame(tf, p.getThreadFactory());
161	–	p.shutdown();
161		joinPool(p);
162		}
163
#	Line 184 | Line 183 | public class ThreadPoolExecutorTest exte
183		RejectedExecutionHandler h = new NoOpREHandler();
184		ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h);
185		assertSame(h, p.getRejectedExecutionHandler());
187	–	p.shutdown();
186		joinPool(p);
187		}
188
#	Line 197 | Line 195 | public class ThreadPoolExecutorTest exte
195		RejectedExecutionHandler h = new NoOpREHandler();
196		p.setRejectedExecutionHandler(h);
197		assertSame(h, p.getRejectedExecutionHandler());
200	–	p.shutdown();
198		joinPool(p);
199		}
200
#	Line 280 | Line 277 | public class ThreadPoolExecutorTest exte
277
278		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
279		assertFalse(p1.isShutdown());
280	<	p1.shutdown();
280	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
281		assertTrue(p1.isShutdown());
282		joinPool(p1);
283		}
#	Line 295 | Line 292 | public class ThreadPoolExecutorTest exte
292		try {
293		p1.execute(new MediumRunnable());
294		} finally {
295	<	p1.shutdown();
295	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
296		}
297		try {
298		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 315 | Line 312 | public class ThreadPoolExecutorTest exte
312		p1.execute(new SmallRunnable());
313		assertFalse(p1.isTerminating());
314		} finally {
315	<	p1.shutdown();
315	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
316		}
317		try {
318		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 332 | Line 329 | public class ThreadPoolExecutorTest exte
329		public void testGetQueue() {
330		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
331		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
332	<	CancellableTask[] tasks = new CancellableTask[5];
332	>	FutureTask[] tasks = new FutureTask[5];
333		for(int i = 0; i < 5; i++){
334	<	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
334	>	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
335		p1.execute(tasks[i]);
336		}
337		try {
#	Line 343 | Line 340 | public class ThreadPoolExecutorTest exte
340		assertSame(q, wq);
341		assertFalse(wq.contains(tasks[0]));
342		assertTrue(wq.contains(tasks[4]));
346	–	p1.shutdownNow();
343		} catch(Exception e) {
344		unexpectedException();
345		} finally {
#	Line 357 | Line 353 | public class ThreadPoolExecutorTest exte
353		public void testRemove() {
354		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
355		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
356	<	CancellableTask[] tasks = new CancellableTask[5];
356	>	FutureTask[] tasks = new FutureTask[5];
357		for(int i = 0; i < 5; i++){
358	<	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
358	>	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
359		p1.execute(tasks[i]);
360		}
361		try {
#	Line 373 | Line 369 | public class ThreadPoolExecutorTest exte
369		assertTrue(q.contains(tasks[3]));
370		assertTrue(p1.remove(tasks[3]));
371		assertFalse(q.contains(tasks[3]));
376	–	p1.shutdownNow();
372		} catch(Exception e) {
373		unexpectedException();
374		} finally {
#	Line 386 | Line 381 | public class ThreadPoolExecutorTest exte
381		*/
382		public void testPurge() {
383		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
384	<	CancellableTask[] tasks = new CancellableTask[5];
384	>	FutureTask[] tasks = new FutureTask[5];
385		for(int i = 0; i < 5; i++){
386	<	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
386	>	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
387		p1.execute(tasks[i]);
388		}
389		tasks[4].cancel(true);
#	Line 396 | Line 391 | public class ThreadPoolExecutorTest exte
391		p1.purge();
392		long count = p1.getTaskCount();
393		assertTrue(count >= 2 && count < 5);
399	–	p1.shutdownNow();
394		joinPool(p1);
395		}
396
#	Line 411 | Line 405 | public class ThreadPoolExecutorTest exte
405		p1.execute(new MediumPossiblyInterruptedRunnable());
406		}
407		finally {
408	<	l = p1.shutdownNow();
408	>	try {
409	>	l = p1.shutdownNow();
410	>	} catch (SecurityException ok) { return; }
411	>
412		}
413		assertTrue(p1.isShutdown());
414		assertTrue(l.size() <= 4);
#	Line 772 | Line 769 | public class ThreadPoolExecutorTest exte
769		for(int i = 1; i < 5; ++i) {
770		assertTrue(tasks[i].done);
771		}
775	–	p.shutdownNow();
772		} catch(RejectedExecutionException ex){
773		unexpectedException();
774		} finally {
#	Line 799 | Line 795 | public class ThreadPoolExecutorTest exte
795		for(int i = 0; i < 5; ++i){
796		assertFalse(tasks[i].done);
797		}
802	–	p.shutdownNow();
798		} catch(RejectedExecutionException ex){
799		unexpectedException();
800		} finally {
#	Line 822 | Line 817 | public class ThreadPoolExecutorTest exte
817		p.execute(r3);
818		assertFalse(p.getQueue().contains(r2));
819		assertTrue(p.getQueue().contains(r3));
825	–	p.shutdownNow();
820		} catch(RejectedExecutionException ex){
821		unexpectedException();
822		} finally {
#	Line 836 | Line 830 | public class ThreadPoolExecutorTest exte
830		public void testRejectedExecutionExceptionOnShutdown() {
831		ThreadPoolExecutor tpe =
832		new ThreadPoolExecutor(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
833	<	tpe.shutdown();
833	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
834		try {
835		tpe.execute(new NoOpRunnable());
836		shouldThrow();
#	Line 852 | Line 846 | public class ThreadPoolExecutorTest exte
846		RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
847		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
848
849	<	p.shutdown();
849	>	try { p.shutdown(); } catch(SecurityException ok) { return; }
850		try {
851		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
852		p.execute(r);
#	Line 871 | Line 865 | public class ThreadPoolExecutorTest exte
865		RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
866		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
867
868	<	p.shutdown();
868	>	try { p.shutdown(); } catch(SecurityException ok) { return; }
869		try {
870		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
871		p.execute(r);
#	Line 891 | Line 885 | public class ThreadPoolExecutorTest exte
885		RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
886		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
887
888	<	p.shutdown();
888	>	try { p.shutdown(); } catch(SecurityException ok) { return; }
889		try {
890		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
891		p.execute(r);
#	Line 931 | Line 925 | public class ThreadPoolExecutorTest exte
925		shouldThrow();
926		} catch(IllegalArgumentException success){
927		} finally {
928	<	tpe.shutdown();
928	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
929		}
930		joinPool(tpe);
931		}
#	Line 950 | Line 944 | public class ThreadPoolExecutorTest exte
944		shouldThrow();
945		} catch(IllegalArgumentException success){
946		} finally {
947	<	tpe.shutdown();
947	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
948		}
949		joinPool(tpe);
950		}
#	Line 969 | Line 963 | public class ThreadPoolExecutorTest exte
963		shouldThrow();
964		} catch(IllegalArgumentException success){
965		} finally {
966	<	tpe.shutdown();
966	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
967		}
968		joinPool(tpe);
969		}
#	Line 990 | Line 984 | public class ThreadPoolExecutorTest exte
984		shouldThrow();
985		} catch(IllegalArgumentException success){
986		} finally {
987	<	tpe.shutdown();
987	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
988		}
989		joinPool(tpe);
990		}
#	Line 1000 | Line 994 | public class ThreadPoolExecutorTest exte
994		*/
995		public void testTerminated() {
996		ExtendedTPE tpe = new ExtendedTPE();
997	<	tpe.shutdown();
997	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
998		assertTrue(tpe.terminatedCalled);
999		joinPool(tpe);
1000		}
#	Line 1017 | Line 1011 | public class ThreadPoolExecutorTest exte
1011		assertTrue(r.done);
1012		assertTrue(tpe.beforeCalled);
1013		assertTrue(tpe.afterCalled);
1014	<	tpe.shutdown();
1014	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1015		}
1016		catch(Exception ex) {
1017		unexpectedException();
#	Line 1025 | Line 1019 | public class ThreadPoolExecutorTest exte
1019		joinPool(tpe);
1020		}
1021		}
1022	+
1023	+	/**
1024	+	* completed submit of callable returns result
1025	+	*/
1026	+	public void testSubmitCallable() {
1027	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1028	+	try {
1029	+	Future<String> future = e.submit(new StringTask());
1030	+	String result = future.get();
1031	+	assertSame(TEST_STRING, result);
1032	+	}
1033	+	catch (ExecutionException ex) {
1034	+	unexpectedException();
1035	+	}
1036	+	catch (InterruptedException ex) {
1037	+	unexpectedException();
1038	+	} finally {
1039	+	joinPool(e);
1040	+	}
1041	+	}
1042	+
1043	+	/**
1044	+	* completed submit of runnable returns successfully
1045	+	*/
1046	+	public void testSubmitRunnable() {
1047	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1048	+	try {
1049	+	Future<?> future = e.submit(new NoOpRunnable());
1050	+	future.get();
1051	+	assertTrue(future.isDone());
1052	+	}
1053	+	catch (ExecutionException ex) {
1054	+	unexpectedException();
1055	+	}
1056	+	catch (InterruptedException ex) {
1057	+	unexpectedException();
1058	+	} finally {
1059	+	joinPool(e);
1060	+	}
1061	+	}
1062	+
1063	+	/**
1064	+	* completed submit of (runnable, result) returns result
1065	+	*/
1066	+	public void testSubmitRunnable2() {
1067	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1068	+	try {
1069	+	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
1070	+	String result = future.get();
1071	+	assertSame(TEST_STRING, result);
1072	+	}
1073	+	catch (ExecutionException ex) {
1074	+	unexpectedException();
1075	+	}
1076	+	catch (InterruptedException ex) {
1077	+	unexpectedException();
1078	+	} finally {
1079	+	joinPool(e);
1080	+	}
1081	+	}
1082	+
1083	+
1084	+
1085	+
1086	+
1087	+	/**
1088	+	* invokeAny(null) throws NPE
1089	+	*/
1090	+	public void testInvokeAny1() {
1091	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1092	+	try {
1093	+	e.invokeAny(null);
1094	+	} catch (NullPointerException success) {
1095	+	} catch(Exception ex) {
1096	+	unexpectedException();
1097	+	} finally {
1098	+	joinPool(e);
1099	+	}
1100	+	}
1101	+
1102	+	/**
1103	+	* invokeAny(empty collection) throws IAE
1104	+	*/
1105	+	public void testInvokeAny2() {
1106	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1107	+	try {
1108	+	e.invokeAny(new ArrayList<Callable<String>>());
1109	+	} catch (IllegalArgumentException success) {
1110	+	} catch(Exception ex) {
1111	+	unexpectedException();
1112	+	} finally {
1113	+	joinPool(e);
1114	+	}
1115	+	}
1116	+
1117	+	/**
1118	+	* invokeAny(c) throws NPE if c has null elements
1119	+	*/
1120	+	public void testInvokeAny3() {
1121	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1122	+	try {
1123	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1124	+	l.add(new StringTask());
1125	+	l.add(null);
1126	+	e.invokeAny(l);
1127	+	} catch (NullPointerException success) {
1128	+	} catch(Exception ex) {
1129	+	unexpectedException();
1130	+	} finally {
1131	+	joinPool(e);
1132	+	}
1133	+	}
1134	+
1135	+	/**
1136	+	* invokeAny(c) throws ExecutionException if no task completes
1137	+	*/
1138	+	public void testInvokeAny4() {
1139	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1140	+	try {
1141	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1142	+	l.add(new NPETask());
1143	+	e.invokeAny(l);
1144	+	} catch (ExecutionException success) {
1145	+	} catch(Exception ex) {
1146	+	unexpectedException();
1147	+	} finally {
1148	+	joinPool(e);
1149	+	}
1150	+	}
1151	+
1152	+	/**
1153	+	* invokeAny(c) returns result of some task
1154	+	*/
1155	+	public void testInvokeAny5() {
1156	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1157	+	try {
1158	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1159	+	l.add(new StringTask());
1160	+	l.add(new StringTask());
1161	+	String result = e.invokeAny(l);
1162	+	assertSame(TEST_STRING, result);
1163	+	} catch (ExecutionException success) {
1164	+	} catch(Exception ex) {
1165	+	unexpectedException();
1166	+	} finally {
1167	+	joinPool(e);
1168	+	}
1169	+	}
1170	+
1171	+	/**
1172	+	* invokeAll(null) throws NPE
1173	+	*/
1174	+	public void testInvokeAll1() {
1175	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1176	+	try {
1177	+	e.invokeAll(null);
1178	+	} catch (NullPointerException success) {
1179	+	} catch(Exception ex) {
1180	+	unexpectedException();
1181	+	} finally {
1182	+	joinPool(e);
1183	+	}
1184	+	}
1185	+
1186	+	/**
1187	+	* invokeAll(empty collection) returns empty collection
1188	+	*/
1189	+	public void testInvokeAll2() {
1190	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1191	+	try {
1192	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1193	+	assertTrue(r.isEmpty());
1194	+	} catch(Exception ex) {
1195	+	unexpectedException();
1196	+	} finally {
1197	+	joinPool(e);
1198	+	}
1199	+	}
1200	+
1201	+	/**
1202	+	* invokeAll(c) throws NPE if c has null elements
1203	+	*/
1204	+	public void testInvokeAll3() {
1205	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1206	+	try {
1207	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1208	+	l.add(new StringTask());
1209	+	l.add(null);
1210	+	e.invokeAll(l);
1211	+	} catch (NullPointerException success) {
1212	+	} catch(Exception ex) {
1213	+	unexpectedException();
1214	+	} finally {
1215	+	joinPool(e);
1216	+	}
1217	+	}
1218	+
1219	+	/**
1220	+	* get of element of invokeAll(c) throws exception on failed task
1221	+	*/
1222	+	public void testInvokeAll4() {
1223	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1224	+	try {
1225	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1226	+	l.add(new NPETask());
1227	+	List<Future<String>> result = e.invokeAll(l);
1228	+	assertEquals(1, result.size());
1229	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1230	+	it.next().get();
1231	+	} catch(ExecutionException success) {
1232	+	} catch(Exception ex) {
1233	+	unexpectedException();
1234	+	} finally {
1235	+	joinPool(e);
1236	+	}
1237	+	}
1238	+
1239	+	/**
1240	+	* invokeAll(c) returns results of all completed tasks
1241	+	*/
1242	+	public void testInvokeAll5() {
1243	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1244	+	try {
1245	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1246	+	l.add(new StringTask());
1247	+	l.add(new StringTask());
1248	+	List<Future<String>> result = e.invokeAll(l);
1249	+	assertEquals(2, result.size());
1250	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1251	+	assertSame(TEST_STRING, it.next().get());
1252	+	} catch (ExecutionException success) {
1253	+	} catch(Exception ex) {
1254	+	unexpectedException();
1255	+	} finally {
1256	+	joinPool(e);
1257	+	}
1258	+	}
1259	+
1260	+
1261	+
1262	+	/**
1263	+	* timed invokeAny(null) throws NPE
1264	+	*/
1265	+	public void testTimedInvokeAny1() {
1266	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1267	+	try {
1268	+	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1269	+	} catch (NullPointerException success) {
1270	+	} catch(Exception ex) {
1271	+	unexpectedException();
1272	+	} finally {
1273	+	joinPool(e);
1274	+	}
1275	+	}
1276	+
1277	+	/**
1278	+	* timed invokeAny(,,null) throws NPE
1279	+	*/
1280	+	public void testTimedInvokeAnyNullTimeUnit() {
1281	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1282	+	try {
1283	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1284	+	l.add(new StringTask());
1285	+	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1286	+	} catch (NullPointerException success) {
1287	+	} catch(Exception ex) {
1288	+	unexpectedException();
1289	+	} finally {
1290	+	joinPool(e);
1291	+	}
1292	+	}
1293	+
1294	+	/**
1295	+	* timed invokeAny(empty collection) throws IAE
1296	+	*/
1297	+	public void testTimedInvokeAny2() {
1298	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1299	+	try {
1300	+	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1301	+	} catch (IllegalArgumentException success) {
1302	+	} catch(Exception ex) {
1303	+	unexpectedException();
1304	+	} finally {
1305	+	joinPool(e);
1306	+	}
1307	+	}
1308	+
1309	+	/**
1310	+	* timed invokeAny(c) throws NPE if c has null elements
1311	+	*/
1312	+	public void testTimedInvokeAny3() {
1313	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1314	+	try {
1315	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1316	+	l.add(new StringTask());
1317	+	l.add(null);
1318	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1319	+	} catch (NullPointerException success) {
1320	+	} catch(Exception ex) {
1321	+	ex.printStackTrace();
1322	+	unexpectedException();
1323	+	} finally {
1324	+	joinPool(e);
1325	+	}
1326	+	}
1327	+
1328	+	/**
1329	+	* timed invokeAny(c) throws ExecutionException if no task completes
1330	+	*/
1331	+	public void testTimedInvokeAny4() {
1332	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1333	+	try {
1334	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1335	+	l.add(new NPETask());
1336	+	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1337	+	} catch(ExecutionException success) {
1338	+	} catch(Exception ex) {
1339	+	unexpectedException();
1340	+	} finally {
1341	+	joinPool(e);
1342	+	}
1343	+	}
1344	+
1345	+	/**
1346	+	* timed invokeAny(c) returns result of some task
1347	+	*/
1348	+	public void testTimedInvokeAny5() {
1349	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1350	+	try {
1351	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1352	+	l.add(new StringTask());
1353	+	l.add(new StringTask());
1354	+	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1355	+	assertSame(TEST_STRING, result);
1356	+	} catch (ExecutionException success) {
1357	+	} catch(Exception ex) {
1358	+	unexpectedException();
1359	+	} finally {
1360	+	joinPool(e);
1361	+	}
1362	+	}
1363	+
1364	+	/**
1365	+	* timed invokeAll(null) throws NPE
1366	+	*/
1367	+	public void testTimedInvokeAll1() {
1368	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1369	+	try {
1370	+	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1371	+	} catch (NullPointerException 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 testTimedInvokeAllNullTimeUnit() {
1383	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1384	+	try {
1385	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1386	+	l.add(new StringTask());
1387	+	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1388	+	} catch (NullPointerException success) {
1389	+	} catch(Exception ex) {
1390	+	unexpectedException();
1391	+	} finally {
1392	+	joinPool(e);
1393	+	}
1394	+	}
1395	+
1396	+	/**
1397	+	* timed invokeAll(empty collection) returns empty collection
1398	+	*/
1399	+	public void testTimedInvokeAll2() {
1400	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1401	+	try {
1402	+	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1403	+	assertTrue(r.isEmpty());
1404	+	} catch(Exception ex) {
1405	+	unexpectedException();
1406	+	} finally {
1407	+	joinPool(e);
1408	+	}
1409	+	}
1410	+
1411	+	/**
1412	+	* timed invokeAll(c) throws NPE if c has null elements
1413	+	*/
1414	+	public void testTimedInvokeAll3() {
1415	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1416	+	try {
1417	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1418	+	l.add(new StringTask());
1419	+	l.add(null);
1420	+	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1421	+	} catch (NullPointerException success) {
1422	+	} catch(Exception ex) {
1423	+	unexpectedException();
1424	+	} finally {
1425	+	joinPool(e);
1426	+	}
1427	+	}
1428	+
1429	+	/**
1430	+	* get of element of invokeAll(c) throws exception on failed task
1431	+	*/
1432	+	public void testTimedInvokeAll4() {
1433	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1434	+	try {
1435	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1436	+	l.add(new NPETask());
1437	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1438	+	assertEquals(1, result.size());
1439	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1440	+	it.next().get();
1441	+	} catch(ExecutionException success) {
1442	+	} catch(Exception ex) {
1443	+	unexpectedException();
1444	+	} finally {
1445	+	joinPool(e);
1446	+	}
1447	+	}
1448	+
1449	+	/**
1450	+	* timed invokeAll(c) returns results of all completed tasks
1451	+	*/
1452	+	public void testTimedInvokeAll5() {
1453	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1454	+	try {
1455	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1456	+	l.add(new StringTask());
1457	+	l.add(new StringTask());
1458	+	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1459	+	assertEquals(2, result.size());
1460	+	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1461	+	assertSame(TEST_STRING, it.next().get());
1462	+	} catch (ExecutionException success) {
1463	+	} catch(Exception ex) {
1464	+	unexpectedException();
1465	+	} finally {
1466	+	joinPool(e);
1467	+	}
1468	+	}
1469	+
1470	+	/**
1471	+	* timed invokeAll(c) cancels tasks not completed by timeout
1472	+	*/
1473	+	public void testTimedInvokeAll6() {
1474	+	ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1475	+	try {
1476	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1477	+	l.add(new StringTask());
1478	+	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1479	+	l.add(new StringTask());
1480	+	List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1481	+	assertEquals(3, result.size());
1482	+	Iterator<Future<String>> it = result.iterator();
1483	+	Future<String> f1 = it.next();
1484	+	Future<String> f2 = it.next();
1485	+	Future<String> f3 = it.next();
1486	+	assertTrue(f1.isDone());
1487	+	assertTrue(f2.isDone());
1488	+	assertTrue(f3.isDone());
1489	+	assertFalse(f1.isCancelled());
1490	+	assertTrue(f2.isCancelled());
1491	+	} catch(Exception ex) {
1492	+	unexpectedException();
1493	+	} finally {
1494	+	joinPool(e);
1495	+	}
1496	+	}
1497	+
1498	+
1499		}

Diff Legend

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