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.13 by dl, Tue Dec 23 19:40:24 2003 UTC vs.
Revision 1.26 by jsr166, Mon Nov 16 05:30:08 2009 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 java.util.concurrent.atomic.*;
11		import junit.framework.*;
12		import java.util.*;
13
14		public class ThreadPoolExecutorTest extends JSR166TestCase {
15		public static void main(String[] args) {
16	<	junit.textui.TestRunner.run (suite());
16	>	junit.textui.TestRunner.run (suite());
17		}
18		public static Test suite() {
19		return new TestSuite(ThreadPoolExecutorTest.class);
20		}
21	<
21	>
22		static class ExtendedTPE extends ThreadPoolExecutor {
23		volatile boolean beforeCalled = false;
24		volatile boolean afterCalled = false;
#	Line 35 | Line 37 | public class ThreadPoolExecutorTest exte
37		}
38		}
39
40	+	static class FailingThreadFactory implements ThreadFactory {
41	+	int calls = 0;
42	+	public Thread newThread(Runnable r) {
43	+	if (++calls > 1) return null;
44	+	return new Thread(r);
45	+	}
46	+	}
47	+
48	+
49		/**
50		*  execute successfully executes a runnable
51		*/
#	Line 45 | Line 56 | public class ThreadPoolExecutorTest exte
56		public void run() {
57		try {
58		Thread.sleep(SHORT_DELAY_MS);
59	<	} catch(InterruptedException e){
59	>	} catch (InterruptedException e) {
60		threadUnexpectedException();
61		}
62		}
63		});
64		Thread.sleep(SMALL_DELAY_MS);
65	<	} catch(InterruptedException e){
65	>	} catch (InterruptedException e) {
66		unexpectedException();
67	<	}
67	>	}
68		joinPool(p1);
69		}
70
#	Line 67 | Line 78 | public class ThreadPoolExecutorTest exte
78		p2.execute(new MediumRunnable());
79		try {
80		Thread.sleep(SHORT_DELAY_MS);
81	<	} catch(Exception e){
81	>	} catch (Exception e) {
82		unexpectedException();
83		}
84		assertEquals(1, p2.getActiveCount());
#	Line 101 | Line 112 | public class ThreadPoolExecutorTest exte
112		assertEquals(2, p2.getPoolSize());
113		joinPool(p2);
114		}
115	<
115	>
116		/**
117		*   getCompletedTaskCount increases, but doesn't overestimate,
118		*   when tasks complete
#	Line 112 | Line 123 | public class ThreadPoolExecutorTest exte
123		p2.execute(new ShortRunnable());
124		try {
125		Thread.sleep(SMALL_DELAY_MS);
126	<	} catch(Exception e){
126	>	} catch (Exception e) {
127		unexpectedException();
128		}
129		assertEquals(1, p2.getCompletedTaskCount());
130	<	p2.shutdown();
130	>	try { p2.shutdown(); } catch (SecurityException ok) { return; }
131		joinPool(p2);
132		}
133	<
133	>
134		/**
135		*   getCorePoolSize returns size given in constructor if not otherwise set
136		*/
#	Line 128 | Line 139 | public class ThreadPoolExecutorTest exte
139		assertEquals(1, p1.getCorePoolSize());
140		joinPool(p1);
141		}
142	<
142	>
143		/**
144		*   getKeepAliveTime returns value given in constructor if not otherwise set
145		*/
#	Line 139 | Line 150 | public class ThreadPoolExecutorTest exte
150		}
151
152
153	<	/**
153	>	/**
154		* getThreadFactory returns factory in constructor if not set
155		*/
156		public void testGetThreadFactory() {
157		ThreadFactory tf = new SimpleThreadFactory();
158		ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler());
159		assertSame(tf, p.getThreadFactory());
149	–	p.shutdown();
160		joinPool(p);
161		}
162
163	<	/**
163	>	/**
164		* setThreadFactory sets the thread factory returned by getThreadFactory
165		*/
166		public void testSetThreadFactory() {
#	Line 158 | Line 168 | public class ThreadPoolExecutorTest exte
168		ThreadFactory tf = new SimpleThreadFactory();
169		p.setThreadFactory(tf);
170		assertSame(tf, p.getThreadFactory());
161	–	p.shutdown();
171		joinPool(p);
172		}
173
174
175	<	/**
175	>	/**
176		* setThreadFactory(null) throws NPE
177		*/
178		public void testSetThreadFactoryNull() {
#	Line 177 | Line 186 | public class ThreadPoolExecutorTest exte
186		}
187		}
188
189	<	/**
189	>	/**
190		* getRejectedExecutionHandler returns handler in constructor if not set
191		*/
192		public void testGetRejectedExecutionHandler() {
193		RejectedExecutionHandler h = new NoOpREHandler();
194		ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h);
195		assertSame(h, p.getRejectedExecutionHandler());
187	–	p.shutdown();
196		joinPool(p);
197		}
198
199	<	/**
199	>	/**
200		* setRejectedExecutionHandler sets the handler returned by
201		* getRejectedExecutionHandler
202		*/
#	Line 197 | Line 205 | public class ThreadPoolExecutorTest exte
205		RejectedExecutionHandler h = new NoOpREHandler();
206		p.setRejectedExecutionHandler(h);
207		assertSame(h, p.getRejectedExecutionHandler());
200	–	p.shutdown();
208		joinPool(p);
209		}
210
211
212	<	/**
212	>	/**
213		* setRejectedExecutionHandler(null) throws NPE
214		*/
215		public void testSetRejectedExecutionHandlerNull() {
#	Line 216 | Line 223 | public class ThreadPoolExecutorTest exte
223		}
224		}
225
226	<
226	>
227		/**
228		*   getLargestPoolSize increases, but doesn't overestimate, when
229		*   multiple threads active
#	Line 229 | Line 236 | public class ThreadPoolExecutorTest exte
236		p2.execute(new MediumRunnable());
237		Thread.sleep(SHORT_DELAY_MS);
238		assertEquals(2, p2.getLargestPoolSize());
239	<	} catch(Exception e){
239	>	} catch (Exception e) {
240		unexpectedException();
241	<	}
241	>	}
242		joinPool(p2);
243		}
244	<
244	>
245		/**
246		*   getMaximumPoolSize returns value given in constructor if not
247		*   otherwise set
#	Line 244 | Line 251 | public class ThreadPoolExecutorTest exte
251		assertEquals(2, p2.getMaximumPoolSize());
252		joinPool(p2);
253		}
254	<
254	>
255		/**
256		*   getPoolSize increases, but doesn't overestimate, when threads
257		*   become active
#	Line 256 | Line 263 | public class ThreadPoolExecutorTest exte
263		assertEquals(1, p1.getPoolSize());
264		joinPool(p1);
265		}
266	<
266	>
267		/**
268		*  getTaskCount increases, but doesn't overestimate, when tasks submitted
269		*/
#	Line 267 | Line 274 | public class ThreadPoolExecutorTest exte
274		p1.execute(new MediumRunnable());
275		Thread.sleep(SHORT_DELAY_MS);
276		assertEquals(1, p1.getTaskCount());
277	<	} catch(Exception e){
277	>	} catch (Exception e) {
278		unexpectedException();
279	<	}
279	>	}
280		joinPool(p1);
281		}
282	<
282	>
283		/**
284		*   isShutDown is false before shutdown, true after
285		*/
286		public void testIsShutdown() {
287	<
287	>
288		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
289		assertFalse(p1.isShutdown());
290	<	p1.shutdown();
290	>	try { p1.shutdown(); } catch (SecurityException ok) { return; }
291		assertTrue(p1.isShutdown());
292		joinPool(p1);
293		}
294
295	<
295	>
296		/**
297		*  isTerminated is false before termination, true after
298		*/
#	Line 295 | Line 302 | public class ThreadPoolExecutorTest exte
302		try {
303		p1.execute(new MediumRunnable());
304		} finally {
305	<	p1.shutdown();
305	>	try { p1.shutdown(); } catch (SecurityException ok) { return; }
306		}
307		try {
308		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
309		assertTrue(p1.isTerminated());
310	<	} catch(Exception e){
310	>	} catch (Exception e) {
311		unexpectedException();
312	<	}
312	>	}
313		}
314
315		/**
#	Line 315 | Line 322 | public class ThreadPoolExecutorTest exte
322		p1.execute(new SmallRunnable());
323		assertFalse(p1.isTerminating());
324		} finally {
325	<	p1.shutdown();
325	>	try { p1.shutdown(); } catch (SecurityException ok) { return; }
326		}
327		try {
328		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
329		assertTrue(p1.isTerminated());
330		assertFalse(p1.isTerminating());
331	<	} catch(Exception e){
331	>	} catch (Exception e) {
332		unexpectedException();
333	<	}
333	>	}
334		}
335
336		/**
#	Line 333 | Line 340 | public class ThreadPoolExecutorTest exte
340		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
341		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
342		FutureTask[] tasks = new FutureTask[5];
343	<	for(int i = 0; i < 5; i++){
343	>	for (int i = 0; i < 5; i++) {
344		tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
345		p1.execute(tasks[i]);
346		}
#	Line 343 | Line 350 | public class ThreadPoolExecutorTest exte
350		assertSame(q, wq);
351		assertFalse(wq.contains(tasks[0]));
352		assertTrue(wq.contains(tasks[4]));
353	+	for (int i = 1; i < 5; ++i)
354	+	tasks[i].cancel(true);
355		p1.shutdownNow();
356	<	} catch(Exception e) {
356	>	} catch (Exception e) {
357		unexpectedException();
358		} finally {
359		joinPool(p1);
#	Line 358 | Line 367 | public class ThreadPoolExecutorTest exte
367		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
368		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
369		FutureTask[] tasks = new FutureTask[5];
370	<	for(int i = 0; i < 5; i++){
370	>	for (int i = 0; i < 5; i++) {
371		tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
372		p1.execute(tasks[i]);
373		}
#	Line 373 | Line 382 | public class ThreadPoolExecutorTest exte
382		assertTrue(q.contains(tasks[3]));
383		assertTrue(p1.remove(tasks[3]));
384		assertFalse(q.contains(tasks[3]));
385	<	p1.shutdownNow();
377	<	} catch(Exception e) {
385	>	} catch (Exception e) {
386		unexpectedException();
387		} finally {
388		joinPool(p1);
#	Line 387 | Line 395 | public class ThreadPoolExecutorTest exte
395		public void testPurge() {
396		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
397		FutureTask[] tasks = new FutureTask[5];
398	<	for(int i = 0; i < 5; i++){
398	>	for (int i = 0; i < 5; i++) {
399		tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
400		p1.execute(tasks[i]);
401		}
#	Line 396 | Line 404 | public class ThreadPoolExecutorTest exte
404		p1.purge();
405		long count = p1.getTaskCount();
406		assertTrue(count >= 2 && count < 5);
399	–	p1.shutdownNow();
407		joinPool(p1);
408		}
409
#	Line 407 | Line 414 | public class ThreadPoolExecutorTest exte
414		ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
415		List l;
416		try {
417	<	for(int i = 0; i < 5; i++)
417	>	for (int i = 0; i < 5; i++)
418		p1.execute(new MediumPossiblyInterruptedRunnable());
419		}
420		finally {
421	<	l = p1.shutdownNow();
421	>	try {
422	>	l = p1.shutdownNow();
423	>	} catch (SecurityException ok) { return; }
424	>
425		}
426		assertTrue(p1.isShutdown());
427		assertTrue(l.size() <= 4);
428		}
429
430		// Exception Tests
421	–
431
432	<	/**
433	<	* Constructor throws if corePoolSize argument is less than zero
432	>
433	>	/**
434	>	* Constructor throws if corePoolSize argument is less than zero
435		*/
436		public void testConstructor1() {
437		try {
438		new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
439		shouldThrow();
440		}
441	<	catch (IllegalArgumentException success){}
441	>	catch (IllegalArgumentException success) {}
442		}
443	<
444	<	/**
445	<	* Constructor throws if maximumPoolSize is less than zero
443	>
444	>	/**
445	>	* Constructor throws if maximumPoolSize is less than zero
446		*/
447		public void testConstructor2() {
448		try {
449		new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
450		shouldThrow();
451		}
452	<	catch (IllegalArgumentException success){}
452	>	catch (IllegalArgumentException success) {}
453		}
454	<
455	<	/**
456	<	* Constructor throws if maximumPoolSize is equal to zero
454	>
455	>	/**
456	>	* Constructor throws if maximumPoolSize is equal to zero
457		*/
458		public void testConstructor3() {
459		try {
460		new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
461		shouldThrow();
462		}
463	<	catch (IllegalArgumentException success){}
463	>	catch (IllegalArgumentException success) {}
464		}
465
466	<	/**
467	<	* Constructor throws if keepAliveTime is less than zero
466	>	/**
467	>	* Constructor throws if keepAliveTime is less than zero
468		*/
469		public void testConstructor4() {
470		try {
471		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
472		shouldThrow();
473		}
474	<	catch (IllegalArgumentException success){}
474	>	catch (IllegalArgumentException success) {}
475		}
476
477	<	/**
478	<	* Constructor throws if corePoolSize is greater than the maximumPoolSize
477	>	/**
478	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
479		*/
480		public void testConstructor5() {
481		try {
482		new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
483		shouldThrow();
484		}
485	<	catch (IllegalArgumentException success){}
485	>	catch (IllegalArgumentException success) {}
486		}
487	<
488	<	/**
489	<	* Constructor throws if workQueue is set to null
487	>
488	>	/**
489	>	* Constructor throws if workQueue is set to null
490		*/
491		public void testConstructorNullPointerException() {
492		try {
493		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null);
494		shouldThrow();
495		}
496	<	catch (NullPointerException success){}
496	>	catch (NullPointerException success) {}
497		}
488	–
498
499	<
500	<	/**
501	<	* Constructor throws if corePoolSize argument is less than zero
499	>
500	>
501	>	/**
502	>	* Constructor throws if corePoolSize argument is less than zero
503		*/
504		public void testConstructor6() {
505		try {
506		new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
507		shouldThrow();
508	<	} catch (IllegalArgumentException success){}
508	>	} catch (IllegalArgumentException success) {}
509		}
510	<
511	<	/**
512	<	* Constructor throws if maximumPoolSize is less than zero
510	>
511	>	/**
512	>	* Constructor throws if maximumPoolSize is less than zero
513		*/
514		public void testConstructor7() {
515		try {
516		new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
517		shouldThrow();
518		}
519	<	catch (IllegalArgumentException success){}
519	>	catch (IllegalArgumentException success) {}
520		}
521
522	<	/**
523	<	* Constructor throws if maximumPoolSize is equal to zero
522	>	/**
523	>	* Constructor throws if maximumPoolSize is equal to zero
524		*/
525		public void testConstructor8() {
526		try {
527		new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
528		shouldThrow();
529		}
530	<	catch (IllegalArgumentException success){}
530	>	catch (IllegalArgumentException success) {}
531		}
532
533	<	/**
534	<	* Constructor throws if keepAliveTime is less than zero
533	>	/**
534	>	* Constructor throws if keepAliveTime is less than zero
535		*/
536		public void testConstructor9() {
537		try {
538		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
539		shouldThrow();
540		}
541	<	catch (IllegalArgumentException success){}
541	>	catch (IllegalArgumentException success) {}
542		}
543
544	<	/**
545	<	* Constructor throws if corePoolSize is greater than the maximumPoolSize
544	>	/**
545	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
546		*/
547		public void testConstructor10() {
548		try {
549		new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
550		shouldThrow();
551		}
552	<	catch (IllegalArgumentException success){}
552	>	catch (IllegalArgumentException success) {}
553		}
554
555	<	/**
556	<	* Constructor throws if workQueue is set to null
555	>	/**
556	>	* Constructor throws if workQueue is set to null
557		*/
558		public void testConstructorNullPointerException2() {
559		try {
560		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory());
561		shouldThrow();
562		}
563	<	catch (NullPointerException success){}
563	>	catch (NullPointerException success) {}
564		}
565
566	<	/**
567	<	* Constructor throws if threadFactory is set to null
566	>	/**
567	>	* Constructor throws if threadFactory is set to null
568		*/
569		public void testConstructorNullPointerException3() {
570		try {
#	Line 562 | Line 572 | public class ThreadPoolExecutorTest exte
572		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
573		shouldThrow();
574		}
575	<	catch (NullPointerException success){}
575	>	catch (NullPointerException success) {}
576		}
577	<
578	<
579	<	/**
580	<	* Constructor throws if corePoolSize argument is less than zero
577	>
578	>
579	>	/**
580	>	* Constructor throws if corePoolSize argument is less than zero
581		*/
582		public void testConstructor11() {
583		try {
584		new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
585		shouldThrow();
586		}
587	<	catch (IllegalArgumentException success){}
587	>	catch (IllegalArgumentException success) {}
588		}
589
590	<	/**
591	<	* Constructor throws if maximumPoolSize is less than zero
590	>	/**
591	>	* Constructor throws if maximumPoolSize is less than zero
592		*/
593		public void testConstructor12() {
594		try {
595		new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
596		shouldThrow();
597		}
598	<	catch (IllegalArgumentException success){}
598	>	catch (IllegalArgumentException success) {}
599		}
600
601	<	/**
602	<	* Constructor throws if maximumPoolSize is equal to zero
601	>	/**
602	>	* Constructor throws if maximumPoolSize is equal to zero
603		*/
604		public void testConstructor13() {
605		try {
606		new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
607		shouldThrow();
608		}
609	<	catch (IllegalArgumentException success){}
609	>	catch (IllegalArgumentException success) {}
610		}
611
612	<	/**
613	<	* Constructor throws if keepAliveTime is less than zero
612	>	/**
613	>	* Constructor throws if keepAliveTime is less than zero
614		*/
615		public void testConstructor14() {
616		try {
617		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
618		shouldThrow();
619		}
620	<	catch (IllegalArgumentException success){}
620	>	catch (IllegalArgumentException success) {}
621		}
622
623	<	/**
624	<	* Constructor throws if corePoolSize is greater than the maximumPoolSize
623	>	/**
624	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
625		*/
626		public void testConstructor15() {
627		try {
628		new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
629		shouldThrow();
630		}
631	<	catch (IllegalArgumentException success){}
631	>	catch (IllegalArgumentException success) {}
632		}
633
634	<	/**
635	<	* Constructor throws if workQueue is set to null
634	>	/**
635	>	* Constructor throws if workQueue is set to null
636		*/
637		public void testConstructorNullPointerException4() {
638		try {
639		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler());
640		shouldThrow();
641		}
642	<	catch (NullPointerException success){}
642	>	catch (NullPointerException success) {}
643		}
644
645	<	/**
646	<	* Constructor throws if handler is set to null
645	>	/**
646	>	* Constructor throws if handler is set to null
647		*/
648		public void testConstructorNullPointerException5() {
649		try {
#	Line 641 | Line 651 | public class ThreadPoolExecutorTest exte
651		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
652		shouldThrow();
653		}
654	<	catch (NullPointerException success){}
654	>	catch (NullPointerException success) {}
655		}
656
657	<
658	<	/**
659	<	* Constructor throws if corePoolSize argument is less than zero
657	>
658	>	/**
659	>	* Constructor throws if corePoolSize argument is less than zero
660		*/
661		public void testConstructor16() {
662		try {
663		new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
664		shouldThrow();
665		}
666	<	catch (IllegalArgumentException success){}
666	>	catch (IllegalArgumentException success) {}
667		}
668
669	<	/**
670	<	* Constructor throws if maximumPoolSize is less than zero
669	>	/**
670	>	* Constructor throws if maximumPoolSize is less than zero
671		*/
672		public void testConstructor17() {
673		try {
674		new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
675		shouldThrow();
676		}
677	<	catch (IllegalArgumentException success){}
677	>	catch (IllegalArgumentException success) {}
678		}
679
680	<	/**
681	<	* Constructor throws if maximumPoolSize is equal to zero
680	>	/**
681	>	* Constructor throws if maximumPoolSize is equal to zero
682		*/
683		public void testConstructor18() {
684		try {
685		new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
686		shouldThrow();
687		}
688	<	catch (IllegalArgumentException success){}
688	>	catch (IllegalArgumentException success) {}
689		}
690
691	<	/**
692	<	* Constructor throws if keepAliveTime is less than zero
691	>	/**
692	>	* Constructor throws if keepAliveTime is less than zero
693		*/
694		public void testConstructor19() {
695		try {
696		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
697		shouldThrow();
698		}
699	<	catch (IllegalArgumentException success){}
699	>	catch (IllegalArgumentException success) {}
700		}
701
702	<	/**
703	<	* Constructor throws if corePoolSize is greater than the maximumPoolSize
702	>	/**
703	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
704		*/
705		public void testConstructor20() {
706		try {
707		new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
708		shouldThrow();
709		}
710	<	catch (IllegalArgumentException success){}
710	>	catch (IllegalArgumentException success) {}
711		}
712
713	<	/**
714	<	* Constructor throws if workQueue is set to null
713	>	/**
714	>	* Constructor throws if workQueue is set to null
715		*/
716		public void testConstructorNullPointerException6() {
717		try {
718		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
719		shouldThrow();
720		}
721	<	catch (NullPointerException success){}
721	>	catch (NullPointerException success) {}
722		}
723
724	<	/**
725	<	* Constructor throws if handler is set to null
724	>	/**
725	>	* Constructor throws if handler is set to null
726		*/
727		public void testConstructorNullPointerException7() {
728		try {
#	Line 720 | Line 730 | public class ThreadPoolExecutorTest exte
730		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
731		shouldThrow();
732		}
733	<	catch (NullPointerException success){}
733	>	catch (NullPointerException success) {}
734		}
735
736	<	/**
737	<	* Constructor throws if ThreadFactory is set top null
736	>	/**
737	>	* Constructor throws if ThreadFactory is set top null
738		*/
739		public void testConstructorNullPointerException8() {
740		try {
#	Line 732 | Line 742 | public class ThreadPoolExecutorTest exte
742		new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
743		shouldThrow();
744		}
745	<	catch (NullPointerException successdn8){}
745	>	catch (NullPointerException successdn8) {}
746		}
747	<
747	>
748
749		/**
750		*  execute throws RejectedExecutionException
#	Line 743 | Line 753 | public class ThreadPoolExecutorTest exte
753		public void testSaturatedExecute() {
754		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
755		try {
756	<
757	<	for(int i = 0; i < 5; ++i){
756	>
757	>	for (int i = 0; i < 5; ++i) {
758		p.execute(new MediumRunnable());
759		}
760		shouldThrow();
761	<	} catch(RejectedExecutionException success){}
761	>	} catch (RejectedExecutionException success) {}
762		joinPool(p);
763		}
764
#	Line 759 | Line 769 | public class ThreadPoolExecutorTest exte
769		RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
770		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
771		try {
772	<
772	>
773		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
774	<	for(int i = 0; i < 5; ++i){
774	>	for (int i = 0; i < 5; ++i) {
775		tasks[i] = new TrackedNoOpRunnable();
776		}
777		TrackedLongRunnable mr = new TrackedLongRunnable();
778		p.execute(mr);
779	<	for(int i = 0; i < 5; ++i){
779	>	for (int i = 0; i < 5; ++i) {
780		p.execute(tasks[i]);
781		}
782	<	for(int i = 1; i < 5; ++i) {
782	>	for (int i = 1; i < 5; ++i) {
783		assertTrue(tasks[i].done);
784		}
785	<	p.shutdownNow();
786	<	} catch(RejectedExecutionException ex){
785	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
786	>	} catch (RejectedExecutionException ex) {
787		unexpectedException();
788		} finally {
789		joinPool(p);
#	Line 787 | Line 797 | public class ThreadPoolExecutorTest exte
797		RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
798		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
799		try {
800	<
800	>
801		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
802	<	for(int i = 0; i < 5; ++i){
802	>	for (int i = 0; i < 5; ++i) {
803		tasks[i] = new TrackedNoOpRunnable();
804		}
805		p.execute(new TrackedLongRunnable());
806	<	for(int i = 0; i < 5; ++i){
806	>	for (int i = 0; i < 5; ++i) {
807		p.execute(tasks[i]);
808		}
809	<	for(int i = 0; i < 5; ++i){
809	>	for (int i = 0; i < 5; ++i) {
810		assertFalse(tasks[i].done);
811		}
812	<	p.shutdownNow();
813	<	} catch(RejectedExecutionException ex){
812	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
813	>	} catch (RejectedExecutionException ex) {
814		unexpectedException();
815		} finally {
816		joinPool(p);
#	Line 822 | Line 832 | public class ThreadPoolExecutorTest exte
832		p.execute(r3);
833		assertFalse(p.getQueue().contains(r2));
834		assertTrue(p.getQueue().contains(r3));
835	<	p.shutdownNow();
836	<	} catch(RejectedExecutionException ex){
835	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
836	>	} catch (RejectedExecutionException ex) {
837		unexpectedException();
838		} finally {
839		joinPool(p);
#	Line 834 | Line 844 | public class ThreadPoolExecutorTest exte
844		*  execute throws RejectedExecutionException if shutdown
845		*/
846		public void testRejectedExecutionExceptionOnShutdown() {
847	<	ThreadPoolExecutor tpe =
847	>	ThreadPoolExecutor tpe =
848		new ThreadPoolExecutor(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
849	<	tpe.shutdown();
849	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
850		try {
851		tpe.execute(new NoOpRunnable());
852		shouldThrow();
853	<	} catch(RejectedExecutionException success){}
854	<
853	>	} catch (RejectedExecutionException success) {}
854	>
855		joinPool(tpe);
856		}
857
#	Line 852 | Line 862 | public class ThreadPoolExecutorTest exte
862		RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
863		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
864
865	<	p.shutdown();
865	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
866		try {
867		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
868		p.execute(r);
869		assertFalse(r.done);
870	<	} catch(RejectedExecutionException success){
870	>	} catch (RejectedExecutionException success) {
871		unexpectedException();
872		} finally {
873		joinPool(p);
#	Line 871 | Line 881 | public class ThreadPoolExecutorTest exte
881		RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
882		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
883
884	<	p.shutdown();
884	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
885		try {
886		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
887		p.execute(r);
888		assertFalse(r.done);
889	<	} catch(RejectedExecutionException success){
889	>	} catch (RejectedExecutionException success) {
890		unexpectedException();
891		} finally {
892		joinPool(p);
#	Line 891 | Line 901 | public class ThreadPoolExecutorTest exte
901		RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
902		ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
903
904	<	p.shutdown();
904	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
905		try {
906		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
907		p.execute(r);
908		assertFalse(r.done);
909	<	} catch(RejectedExecutionException success){
909	>	} catch (RejectedExecutionException success) {
910		unexpectedException();
911		} finally {
912		joinPool(p);
#	Line 913 | Line 923 | public class ThreadPoolExecutorTest exte
923		tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
924		tpe.execute(null);
925		shouldThrow();
926	<	} catch(NullPointerException success){}
927	<
926	>	} catch (NullPointerException success) {}
927	>
928		joinPool(tpe);
929		}
930	<
930	>
931		/**
932		*  setCorePoolSize of negative value throws IllegalArgumentException
933		*/
#	Line 925 | Line 935 | public class ThreadPoolExecutorTest exte
935		ThreadPoolExecutor tpe = null;
936		try {
937		tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
938	<	} catch(Exception e){}
938	>	} catch (Exception e) {}
939		try {
940		tpe.setCorePoolSize(-1);
941		shouldThrow();
942	<	} catch(IllegalArgumentException success){
942	>	} catch (IllegalArgumentException success) {
943		} finally {
944	<	tpe.shutdown();
944	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
945		}
946		joinPool(tpe);
947	<	}
947	>	}
948
949		/**
950		*  setMaximumPoolSize(int) throws IllegalArgumentException if
951		*  given a value less the core pool size
952	<	*/
952	>	*/
953		public void testMaximumPoolSizeIllegalArgumentException() {
954		ThreadPoolExecutor tpe = null;
955		try {
956		tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
957	<	} catch(Exception e){}
957	>	} catch (Exception e) {}
958		try {
959		tpe.setMaximumPoolSize(1);
960		shouldThrow();
961	<	} catch(IllegalArgumentException success){
961	>	} catch (IllegalArgumentException success) {
962		} finally {
963	<	tpe.shutdown();
963	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
964		}
965		joinPool(tpe);
966		}
967	<
967	>
968		/**
969		*  setMaximumPoolSize throws IllegalArgumentException
970		*  if given a negative value
#	Line 963 | Line 973 | public class ThreadPoolExecutorTest exte
973		ThreadPoolExecutor tpe = null;
974		try {
975		tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
976	<	} catch(Exception e){}
976	>	} catch (Exception e) {}
977		try {
978		tpe.setMaximumPoolSize(-1);
979		shouldThrow();
980	<	} catch(IllegalArgumentException success){
980	>	} catch (IllegalArgumentException success) {
981		} finally {
982	<	tpe.shutdown();
982	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
983		}
984		joinPool(tpe);
985		}
986	<
986	>
987
988		/**
989		*  setKeepAliveTime  throws IllegalArgumentException
#	Line 983 | Line 993 | public class ThreadPoolExecutorTest exte
993		ThreadPoolExecutor tpe = null;
994		try {
995		tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
996	<	} catch(Exception e){}
997	<
996	>	} catch (Exception e) {}
997	>
998		try {
999		tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
1000		shouldThrow();
1001	<	} catch(IllegalArgumentException success){
1001	>	} catch (IllegalArgumentException success) {
1002		} finally {
1003	<	tpe.shutdown();
1003	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1004		}
1005		joinPool(tpe);
1006		}
#	Line 1000 | Line 1010 | public class ThreadPoolExecutorTest exte
1010		*/
1011		public void testTerminated() {
1012		ExtendedTPE tpe = new ExtendedTPE();
1013	<	tpe.shutdown();
1013	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1014		assertTrue(tpe.terminatedCalled);
1015		joinPool(tpe);
1016		}
#	Line 1017 | Line 1027 | public class ThreadPoolExecutorTest exte
1027		assertTrue(r.done);
1028		assertTrue(tpe.beforeCalled);
1029		assertTrue(tpe.afterCalled);
1030	<	tpe.shutdown();
1030	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1031		}
1032	<	catch(Exception ex) {
1032	>	catch (Exception ex) {
1033		unexpectedException();
1034		} finally {
1035		joinPool(tpe);
#	Line 1098 | Line 1108 | public class ThreadPoolExecutorTest exte
1108		try {
1109		e.invokeAny(null);
1110		} catch (NullPointerException success) {
1111	<	} catch(Exception ex) {
1111	>	} catch (Exception ex) {
1112		unexpectedException();
1113		} finally {
1114		joinPool(e);
#	Line 1113 | Line 1123 | public class ThreadPoolExecutorTest exte
1123		try {
1124		e.invokeAny(new ArrayList<Callable<String>>());
1125		} catch (IllegalArgumentException success) {
1126	<	} catch(Exception ex) {
1126	>	} catch (Exception ex) {
1127		unexpectedException();
1128		} finally {
1129		joinPool(e);
#	Line 1131 | Line 1141 | public class ThreadPoolExecutorTest exte
1141		l.add(null);
1142		e.invokeAny(l);
1143		} catch (NullPointerException success) {
1144	<	} catch(Exception ex) {
1144	>	} catch (Exception ex) {
1145		unexpectedException();
1146		} finally {
1147		joinPool(e);
#	Line 1148 | Line 1158 | public class ThreadPoolExecutorTest exte
1158		l.add(new NPETask());
1159		e.invokeAny(l);
1160		} catch (ExecutionException success) {
1161	<	} catch(Exception ex) {
1161	>	} catch (Exception ex) {
1162		unexpectedException();
1163		} finally {
1164		joinPool(e);
#	Line 1167 | Line 1177 | public class ThreadPoolExecutorTest exte
1177		String result = e.invokeAny(l);
1178		assertSame(TEST_STRING, result);
1179		} catch (ExecutionException success) {
1180	<	} catch(Exception ex) {
1180	>	} catch (Exception ex) {
1181		unexpectedException();
1182		} finally {
1183		joinPool(e);
#	Line 1182 | Line 1192 | public class ThreadPoolExecutorTest exte
1192		try {
1193		e.invokeAll(null);
1194		} catch (NullPointerException success) {
1195	<	} catch(Exception ex) {
1195	>	} catch (Exception ex) {
1196		unexpectedException();
1197		} finally {
1198		joinPool(e);
#	Line 1197 | Line 1207 | public class ThreadPoolExecutorTest exte
1207		try {
1208		List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1209		assertTrue(r.isEmpty());
1210	<	} catch(Exception ex) {
1210	>	} catch (Exception ex) {
1211		unexpectedException();
1212		} finally {
1213		joinPool(e);
#	Line 1215 | Line 1225 | public class ThreadPoolExecutorTest exte
1225		l.add(null);
1226		e.invokeAll(l);
1227		} catch (NullPointerException success) {
1228	<	} catch(Exception ex) {
1228	>	} catch (Exception ex) {
1229		unexpectedException();
1230		} finally {
1231		joinPool(e);
#	Line 1232 | Line 1242 | public class ThreadPoolExecutorTest exte
1242		l.add(new NPETask());
1243		List<Future<String>> result = e.invokeAll(l);
1244		assertEquals(1, result.size());
1245	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1245	>	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1246		it.next().get();
1247	<	} catch(ExecutionException success) {
1248	<	} catch(Exception ex) {
1247	>	} catch (ExecutionException success) {
1248	>	} catch (Exception ex) {
1249		unexpectedException();
1250		} finally {
1251		joinPool(e);
#	Line 1253 | Line 1263 | public class ThreadPoolExecutorTest exte
1263		l.add(new StringTask());
1264		List<Future<String>> result = e.invokeAll(l);
1265		assertEquals(2, result.size());
1266	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1266	>	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1267		assertSame(TEST_STRING, it.next().get());
1268		} catch (ExecutionException success) {
1269	<	} catch(Exception ex) {
1269	>	} catch (Exception ex) {
1270		unexpectedException();
1271		} finally {
1272		joinPool(e);
#	Line 1273 | Line 1283 | public class ThreadPoolExecutorTest exte
1283		try {
1284		e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1285		} catch (NullPointerException success) {
1286	<	} catch(Exception ex) {
1286	>	} catch (Exception ex) {
1287		unexpectedException();
1288		} finally {
1289		joinPool(e);
#	Line 1290 | Line 1300 | public class ThreadPoolExecutorTest exte
1300		l.add(new StringTask());
1301		e.invokeAny(l, MEDIUM_DELAY_MS, null);
1302		} catch (NullPointerException success) {
1303	<	} catch(Exception ex) {
1303	>	} catch (Exception ex) {
1304		unexpectedException();
1305		} finally {
1306		joinPool(e);
#	Line 1305 | Line 1315 | public class ThreadPoolExecutorTest exte
1315		try {
1316		e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1317		} catch (IllegalArgumentException success) {
1318	<	} catch(Exception ex) {
1318	>	} catch (Exception ex) {
1319		unexpectedException();
1320		} finally {
1321		joinPool(e);
#	Line 1323 | Line 1333 | public class ThreadPoolExecutorTest exte
1333		l.add(null);
1334		e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1335		} catch (NullPointerException success) {
1336	<	} catch(Exception ex) {
1336	>	} catch (Exception ex) {
1337		ex.printStackTrace();
1338		unexpectedException();
1339		} finally {
#	Line 1340 | Line 1350 | public class ThreadPoolExecutorTest exte
1350		ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1351		l.add(new NPETask());
1352		e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1353	<	} catch(ExecutionException success) {
1354	<	} catch(Exception ex) {
1353	>	} catch (ExecutionException success) {
1354	>	} catch (Exception ex) {
1355		unexpectedException();
1356		} finally {
1357		joinPool(e);
#	Line 1360 | Line 1370 | public class ThreadPoolExecutorTest exte
1370		String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1371		assertSame(TEST_STRING, result);
1372		} catch (ExecutionException success) {
1373	<	} catch(Exception ex) {
1373	>	} catch (Exception ex) {
1374		unexpectedException();
1375		} finally {
1376		joinPool(e);
#	Line 1375 | Line 1385 | public class ThreadPoolExecutorTest exte
1385		try {
1386		e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1387		} catch (NullPointerException success) {
1388	<	} catch(Exception ex) {
1388	>	} catch (Exception ex) {
1389		unexpectedException();
1390		} finally {
1391		joinPool(e);
#	Line 1392 | Line 1402 | public class ThreadPoolExecutorTest exte
1402		l.add(new StringTask());
1403		e.invokeAll(l, MEDIUM_DELAY_MS, null);
1404		} catch (NullPointerException success) {
1405	<	} catch(Exception ex) {
1405	>	} catch (Exception ex) {
1406		unexpectedException();
1407		} finally {
1408		joinPool(e);
#	Line 1407 | Line 1417 | public class ThreadPoolExecutorTest exte
1417		try {
1418		List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1419		assertTrue(r.isEmpty());
1420	<	} catch(Exception ex) {
1420	>	} catch (Exception ex) {
1421		unexpectedException();
1422		} finally {
1423		joinPool(e);
#	Line 1425 | Line 1435 | public class ThreadPoolExecutorTest exte
1435		l.add(null);
1436		e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1437		} catch (NullPointerException success) {
1438	<	} catch(Exception ex) {
1438	>	} catch (Exception ex) {
1439		unexpectedException();
1440		} finally {
1441		joinPool(e);
#	Line 1442 | Line 1452 | public class ThreadPoolExecutorTest exte
1452		l.add(new NPETask());
1453		List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1454		assertEquals(1, result.size());
1455	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1455	>	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1456		it.next().get();
1457	<	} catch(ExecutionException success) {
1458	<	} catch(Exception ex) {
1457	>	} catch (ExecutionException success) {
1458	>	} catch (Exception ex) {
1459		unexpectedException();
1460		} finally {
1461		joinPool(e);
#	Line 1463 | Line 1473 | public class ThreadPoolExecutorTest exte
1473		l.add(new StringTask());
1474		List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1475		assertEquals(2, result.size());
1476	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1476	>	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1477		assertSame(TEST_STRING, it.next().get());
1478		} catch (ExecutionException success) {
1479	<	} catch(Exception ex) {
1479	>	} catch (Exception ex) {
1480		unexpectedException();
1481		} finally {
1482		joinPool(e);
#	Line 1481 | Line 1491 | public class ThreadPoolExecutorTest exte
1491		try {
1492		ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1493		l.add(new StringTask());
1494	<	l.add(Executors.callable(new MediumInterruptedRunnable(), TEST_STRING));
1494	>	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1495	>	l.add(new StringTask());
1496		List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1497	<	assertEquals(2, result.size());
1498	<	Iterator<Future<String>> it = result.iterator();
1497	>	assertEquals(3, result.size());
1498	>	Iterator<Future<String>> it = result.iterator();
1499		Future<String> f1 = it.next();
1500		Future<String> f2 = it.next();
1501	+	Future<String> f3 = it.next();
1502		assertTrue(f1.isDone());
1491	–	assertFalse(f1.isCancelled());
1503		assertTrue(f2.isDone());
1504	+	assertTrue(f3.isDone());
1505	+	assertFalse(f1.isCancelled());
1506		assertTrue(f2.isCancelled());
1507	<	} catch(Exception ex) {
1507	>	} catch (Exception ex) {
1508		unexpectedException();
1509		} finally {
1510		joinPool(e);
1511		}
1512		}
1513
1514	+	/**
1515	+	* Execution continues if there is at least one thread even if
1516	+	* thread factory fails to create more
1517	+	*/
1518	+	public void testFailingThreadFactory() {
1519	+	ExecutorService e = new ThreadPoolExecutor(100, 100, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1520	+	try {
1521	+	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1522	+	for (int k = 0; k < 100; ++k) {
1523	+	e.execute(new NoOpRunnable());
1524	+	}
1525	+	Thread.sleep(LONG_DELAY_MS);
1526	+	} catch (Exception ex) {
1527	+	unexpectedException();
1528	+	} finally {
1529	+	joinPool(e);
1530	+	}
1531	+	}
1532	+
1533	+	/**
1534	+	* allowsCoreThreadTimeOut is by default false.
1535	+	*/
1536	+	public void testAllowsCoreThreadTimeOut() {
1537	+	ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1538	+	assertFalse(tpe.allowsCoreThreadTimeOut());
1539	+	joinPool(tpe);
1540	+	}
1541	+
1542	+	/**
1543	+	* allowCoreThreadTimeOut(true) causes idle threads to time out
1544	+	*/
1545	+	public void testAllowCoreThreadTimeOut_true() {
1546	+	ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1547	+	tpe.allowCoreThreadTimeOut(true);
1548	+	tpe.execute(new NoOpRunnable());
1549	+	try {
1550	+	Thread.sleep(MEDIUM_DELAY_MS);
1551	+	assertEquals(0, tpe.getPoolSize());
1552	+	} catch (InterruptedException e) {
1553	+	unexpectedException();
1554	+	} finally {
1555	+	joinPool(tpe);
1556	+	}
1557	+	}
1558	+
1559	+	/**
1560	+	* allowCoreThreadTimeOut(false) causes idle threads not to time out
1561	+	*/
1562	+	public void testAllowCoreThreadTimeOut_false() {
1563	+	ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1564	+	tpe.allowCoreThreadTimeOut(false);
1565	+	tpe.execute(new NoOpRunnable());
1566	+	try {
1567	+	Thread.sleep(MEDIUM_DELAY_MS);
1568	+	assertTrue(tpe.getPoolSize() >= 1);
1569	+	} catch (InterruptedException e) {
1570	+	unexpectedException();
1571	+	} finally {
1572	+	joinPool(tpe);
1573	+	}
1574	+	}
1575	+
1576	+	/**
1577	+	* execute allows the same task to be submitted multiple times, even
1578	+	* if rejected
1579	+	*/
1580	+	public void testRejectedRecycledTask() {
1581	+	final int nTasks = 1000;
1582	+	final AtomicInteger nRun = new AtomicInteger(0);
1583	+	final Runnable recycledTask = new Runnable() {
1584	+	public void run() {
1585	+	nRun.getAndIncrement();
1586	+	} };
1587	+	final ThreadPoolExecutor p =
1588	+	new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
1589	+	new ArrayBlockingQueue(30));
1590	+	try {
1591	+	for (int i = 0; i < nTasks; ++i) {
1592	+	for (;;) {
1593	+	try {
1594	+	p.execute(recycledTask);
1595	+	break;
1596	+	}
1597	+	catch (RejectedExecutionException ignore) {
1598	+	}
1599	+	}
1600	+	}
1601	+	Thread.sleep(5000); // enough time to run all tasks
1602	+	assertEquals(nRun.get(), nTasks);
1603	+	} catch (Exception ex) {
1604	+	ex.printStackTrace();
1605	+	unexpectedException();
1606	+	} finally {
1607	+	p.shutdown();
1608	+	}
1609	+	}
1610
1611		}

Diff Legend

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