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.23 by dl, Tue Aug 23 12:50:00 2005 UTC vs.
Revision 1.25 by jsr166, Mon Nov 16 04:57:10 2009 UTC

#	Line 2 | Line 2
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.
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import java.util.concurrent.*;
#	Line 13 | Line 13 | 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 42 | Line 42 | public class ThreadPoolExecutorTest exte
42		public Thread newThread(Runnable r){
43		if (++calls > 1) return null;
44		return new Thread(r);
45	<	}
45	>	}
46		}
47	<
47	>
48
49		/**
50		*  execute successfully executes a runnable
#	Line 56 | 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 78 | 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 112 | 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 123 | 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	<	try { p2.shutdown(); } catch(SecurityException ok) { return; }
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 139 | 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 150 | 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() {
#	Line 160 | Line 160 | public class ThreadPoolExecutorTest exte
160		joinPool(p);
161		}
162
163	<	/**
163	>	/**
164		* setThreadFactory sets the thread factory returned by getThreadFactory
165		*/
166		public void testSetThreadFactory() {
#	Line 172 | Line 172 | public class ThreadPoolExecutorTest exte
172		}
173
174
175	<	/**
175	>	/**
176		* setThreadFactory(null) throws NPE
177		*/
178		public void testSetThreadFactoryNull() {
#	Line 186 | 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() {
#	Line 196 | Line 196 | public class ThreadPoolExecutorTest exte
196		joinPool(p);
197		}
198
199	<	/**
199	>	/**
200		* setRejectedExecutionHandler sets the handler returned by
201		* getRejectedExecutionHandler
202		*/
#	Line 209 | Line 209 | public class ThreadPoolExecutorTest exte
209		}
210
211
212	<	/**
212	>	/**
213		* setRejectedExecutionHandler(null) throws NPE
214		*/
215		public void testSetRejectedExecutionHandlerNull() {
#	Line 223 | 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 236 | 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 251 | 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 263 | 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 274 | 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	<	try { p1.shutdown(); } catch(SecurityException ok) { return; }
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 302 | Line 302 | public class ThreadPoolExecutorTest exte
302		try {
303		p1.execute(new MediumRunnable());
304		} finally {
305	<	try { p1.shutdown(); } catch(SecurityException ok) { return; }
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 322 | Line 322 | public class ThreadPoolExecutorTest exte
322		p1.execute(new SmallRunnable());
323		assertFalse(p1.isTerminating());
324		} finally {
325	<	try { p1.shutdown(); } catch(SecurityException ok) { return; }
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 340 | 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 353 | Line 353 | public class ThreadPoolExecutorTest exte
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 367 | 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 382 | 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	<	} catch(Exception e) {
385	>	} catch (Exception e) {
386		unexpectedException();
387		} finally {
388		joinPool(p1);
#	Line 395 | 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 414 | 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		try {
422		l = p1.shutdownNow();
423		} catch (SecurityException ok) { return; }
424	<
424	>
425		}
426		assertTrue(p1.isShutdown());
427		assertTrue(l.size() <= 4);
428		}
429
430		// Exception Tests
431	–
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 {
#	Line 440 | Line 440 | public class ThreadPoolExecutorTest exte
440		}
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 {
#	Line 451 | Line 451 | public class ThreadPoolExecutorTest exte
451		}
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 {
#	Line 463 | Line 463 | public class ThreadPoolExecutorTest exte
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 {
#	Line 474 | Line 474 | public class ThreadPoolExecutorTest exte
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 {
#	Line 484 | Line 484 | public class ThreadPoolExecutorTest exte
484		}
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		}
498	–
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 {
#	Line 507 | Line 507 | public class ThreadPoolExecutorTest exte
507		shouldThrow();
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 {
#	Line 519 | Line 519 | public class ThreadPoolExecutorTest exte
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 {
#	Line 530 | Line 530 | public class ThreadPoolExecutorTest exte
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 {
#	Line 541 | Line 541 | public class ThreadPoolExecutorTest exte
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 {
#	Line 552 | Line 552 | public class ThreadPoolExecutorTest exte
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 572 | 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 {
#	Line 587 | Line 587 | public class ThreadPoolExecutorTest exte
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 {
#	Line 598 | Line 598 | public class ThreadPoolExecutorTest exte
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 {
#	Line 609 | Line 609 | public class ThreadPoolExecutorTest exte
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 {
#	Line 620 | Line 620 | public class ThreadPoolExecutorTest exte
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 {
#	Line 631 | Line 631 | public class ThreadPoolExecutorTest exte
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 651 | 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 {
#	Line 666 | Line 666 | public class ThreadPoolExecutorTest exte
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 {
#	Line 677 | Line 677 | public class ThreadPoolExecutorTest exte
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 {
#	Line 688 | Line 688 | public class ThreadPoolExecutorTest exte
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 {
#	Line 699 | Line 699 | public class ThreadPoolExecutorTest exte
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 {
#	Line 710 | Line 710 | public class ThreadPoolExecutorTest exte
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 730 | 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 742 | 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 753 | 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 769 | 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	<	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
786	<	} catch(RejectedExecutionException ex){
785	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
786	>	} catch (RejectedExecutionException ex){
787		unexpectedException();
788		} finally {
789		joinPool(p);
#	Line 797 | 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	<	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
813	<	} catch(RejectedExecutionException ex){
812	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
813	>	} catch (RejectedExecutionException ex){
814		unexpectedException();
815		} finally {
816		joinPool(p);
#	Line 832 | Line 832 | public class ThreadPoolExecutorTest exte
832		p.execute(r3);
833		assertFalse(p.getQueue().contains(r2));
834		assertTrue(p.getQueue().contains(r3));
835	<	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
836	<	} catch(RejectedExecutionException ex){
835	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
836	>	} catch (RejectedExecutionException ex){
837		unexpectedException();
838		} finally {
839		joinPool(p);
#	Line 844 | 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	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
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 862 | 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	<	try { p.shutdown(); } catch(SecurityException ok) { return; }
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 881 | 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	<	try { p.shutdown(); } catch(SecurityException ok) { return; }
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 901 | 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	<	try { p.shutdown(); } catch(SecurityException ok) { return; }
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 923 | 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 935 | 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	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
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	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
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 973 | 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	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
982	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
983		}
984		joinPool(tpe);
985		}
986	<
986	>
987
988		/**
989		*  setKeepAliveTime  throws IllegalArgumentException
#	Line 993 | 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	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1003	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1004		}
1005		joinPool(tpe);
1006		}
#	Line 1010 | Line 1010 | public class ThreadPoolExecutorTest exte
1010		*/
1011		public void testTerminated() {
1012		ExtendedTPE tpe = new ExtendedTPE();
1013	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1013	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1014		assertTrue(tpe.terminatedCalled);
1015		joinPool(tpe);
1016		}
#	Line 1027 | Line 1027 | public class ThreadPoolExecutorTest exte
1027		assertTrue(r.done);
1028		assertTrue(tpe.beforeCalled);
1029		assertTrue(tpe.afterCalled);
1030	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
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 1108 | 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 1123 | 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 1141 | 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 1158 | 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 1177 | 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 1192 | 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 1207 | 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 1225 | 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 1242 | 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 1263 | 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 1283 | 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 1300 | 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 1315 | 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 1333 | 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 1350 | 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 1370 | 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 1385 | 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 1402 | 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 1417 | 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 1435 | 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 1452 | 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 1473 | 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 1495 | Line 1495 | public class ThreadPoolExecutorTest exte
1495		l.add(new StringTask());
1496		List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1497		assertEquals(3, result.size());
1498	<	Iterator<Future<String>> it = result.iterator();
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();
#	Line 1504 | Line 1504 | public class ThreadPoolExecutorTest exte
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);
#	Line 1523 | Line 1523 | public class ThreadPoolExecutorTest exte
1523		e.execute(new NoOpRunnable());
1524		}
1525		Thread.sleep(LONG_DELAY_MS);
1526	<	} catch(Exception ex) {
1526	>	} catch (Exception ex) {
1527		unexpectedException();
1528		} finally {
1529		joinPool(e);
#	Line 1549 | Line 1549 | public class ThreadPoolExecutorTest exte
1549		try {
1550		Thread.sleep(MEDIUM_DELAY_MS);
1551		assertEquals(0, tpe.getPoolSize());
1552	<	} catch(InterruptedException e){
1552	>	} catch (InterruptedException e){
1553		unexpectedException();
1554		} finally {
1555		joinPool(tpe);
#	Line 1566 | Line 1566 | public class ThreadPoolExecutorTest exte
1566		try {
1567		Thread.sleep(MEDIUM_DELAY_MS);
1568		assertTrue(tpe.getPoolSize() >= 1);
1569	<	} catch(InterruptedException e){
1569	>	} catch (InterruptedException e){
1570		unexpectedException();
1571		} finally {
1572		joinPool(tpe);
#	Line 1584 | Line 1584 | public class ThreadPoolExecutorTest exte
1584		public void run() {
1585		nRun.getAndIncrement();
1586		} };
1587	<	final ThreadPoolExecutor p =
1588	<	new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
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) {
#	Line 1600 | Line 1600 | public class ThreadPoolExecutorTest exte
1600		}
1601		Thread.sleep(5000); // enough time to run all tasks
1602		assertEquals(nRun.get(), nTasks);
1603	<	} catch(Exception ex) {
1603	>	} catch (Exception ex) {
1604		ex.printStackTrace();
1605		unexpectedException();
1606		} finally {
1607		p.shutdown();
1608		}
1609		}
1610	<
1610	>
1611		}

Diff Legend

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