ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java (file contents):
Revision 1.2 by jsr166, Mon Nov 2 20:28:32 2009 UTC vs.
Revision 1.4 by jsr166, Mon Nov 16 05:30:08 2009 UTC

#	Line 68 | Line 68 | public class ThreadPoolExecutorSubclassT
68		try {
69		v = callable.call();
70		}
71	<	catch(Exception ex) {
71	>	catch (Exception ex) {
72		e = ex;
73		}
74		lock.lock();
#	Line 93 | Line 93 | public class ThreadPoolExecutorSubclassT
93		finally { lock.unlock(); }
94		}
95		public V get(long timeout, TimeUnit unit)
96	<	throws InterruptedException, ExecutionException, TimeoutException{
96	>	throws InterruptedException, ExecutionException, TimeoutException {
97		long nanos = unit.toNanos(timeout);
98		lock.lock();
99		try {
#	Line 176 | Line 176 | public class ThreadPoolExecutorSubclassT
176
177		}
178
179	<	static class FailingThreadFactory implements ThreadFactory{
179	>	static class FailingThreadFactory implements ThreadFactory {
180		int calls = 0;
181	<	public Thread newThread(Runnable r){
181	>	public Thread newThread(Runnable r) {
182		if (++calls > 1) return null;
183		return new Thread(r);
184		}
#	Line 195 | Line 195 | public class ThreadPoolExecutorSubclassT
195		public void run() {
196		try {
197		Thread.sleep(SHORT_DELAY_MS);
198	<	} catch(InterruptedException e){
198	>	} catch (InterruptedException e) {
199		threadUnexpectedException();
200		}
201		}
202		});
203		Thread.sleep(SMALL_DELAY_MS);
204	<	} catch(InterruptedException e){
204	>	} catch (InterruptedException e) {
205		unexpectedException();
206		}
207		joinPool(p1);
#	Line 217 | Line 217 | public class ThreadPoolExecutorSubclassT
217		p2.execute(new MediumRunnable());
218		try {
219		Thread.sleep(SHORT_DELAY_MS);
220	<	} catch(Exception e){
220	>	} catch (Exception e) {
221		unexpectedException();
222		}
223		assertEquals(1, p2.getActiveCount());
#	Line 262 | Line 262 | public class ThreadPoolExecutorSubclassT
262		p2.execute(new ShortRunnable());
263		try {
264		Thread.sleep(SMALL_DELAY_MS);
265	<	} catch(Exception e){
265	>	} catch (Exception e) {
266		unexpectedException();
267		}
268		assertEquals(1, p2.getCompletedTaskCount());
269	<	try { p2.shutdown(); } catch(SecurityException ok) { return; }
269	>	try { p2.shutdown(); } catch (SecurityException ok) { return; }
270		joinPool(p2);
271		}
272
#	Line 375 | Line 375 | public class ThreadPoolExecutorSubclassT
375		p2.execute(new MediumRunnable());
376		Thread.sleep(SHORT_DELAY_MS);
377		assertEquals(2, p2.getLargestPoolSize());
378	<	} catch(Exception e){
378	>	} catch (Exception e) {
379		unexpectedException();
380		}
381		joinPool(p2);
#	Line 413 | Line 413 | public class ThreadPoolExecutorSubclassT
413		p1.execute(new MediumRunnable());
414		Thread.sleep(SHORT_DELAY_MS);
415		assertEquals(1, p1.getTaskCount());
416	<	} catch(Exception e){
416	>	} catch (Exception e) {
417		unexpectedException();
418		}
419		joinPool(p1);
#	Line 426 | Line 426 | public class ThreadPoolExecutorSubclassT
426
427		ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
428		assertFalse(p1.isShutdown());
429	<	try { p1.shutdown(); } catch(SecurityException ok) { return; }
429	>	try { p1.shutdown(); } catch (SecurityException ok) { return; }
430		assertTrue(p1.isShutdown());
431		joinPool(p1);
432		}
#	Line 441 | Line 441 | public class ThreadPoolExecutorSubclassT
441		try {
442		p1.execute(new MediumRunnable());
443		} finally {
444	<	try { p1.shutdown(); } catch(SecurityException ok) { return; }
444	>	try { p1.shutdown(); } catch (SecurityException ok) { return; }
445		}
446		try {
447		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
448		assertTrue(p1.isTerminated());
449	<	} catch(Exception e){
449	>	} catch (Exception e) {
450		unexpectedException();
451		}
452		}
#	Line 461 | Line 461 | public class ThreadPoolExecutorSubclassT
461		p1.execute(new SmallRunnable());
462		assertFalse(p1.isTerminating());
463		} finally {
464	<	try { p1.shutdown(); } catch(SecurityException ok) { return; }
464	>	try { p1.shutdown(); } catch (SecurityException ok) { return; }
465		}
466		try {
467		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
468		assertTrue(p1.isTerminated());
469		assertFalse(p1.isTerminating());
470	<	} catch(Exception e){
470	>	} catch (Exception e) {
471		unexpectedException();
472		}
473		}
#	Line 479 | Line 479 | public class ThreadPoolExecutorSubclassT
479		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
480		ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
481		FutureTask[] tasks = new FutureTask[5];
482	<	for(int i = 0; i < 5; i++){
482	>	for (int i = 0; i < 5; i++) {
483		tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
484		p1.execute(tasks[i]);
485		}
#	Line 492 | Line 492 | public class ThreadPoolExecutorSubclassT
492		for (int i = 1; i < 5; ++i)
493		tasks[i].cancel(true);
494		p1.shutdownNow();
495	<	} catch(Exception e) {
495	>	} catch (Exception e) {
496		unexpectedException();
497		} finally {
498		joinPool(p1);
#	Line 506 | Line 506 | public class ThreadPoolExecutorSubclassT
506		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
507		ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
508		FutureTask[] tasks = new FutureTask[5];
509	<	for(int i = 0; i < 5; i++){
509	>	for (int i = 0; i < 5; i++) {
510		tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
511		p1.execute(tasks[i]);
512		}
#	Line 521 | Line 521 | public class ThreadPoolExecutorSubclassT
521		assertTrue(q.contains(tasks[3]));
522		assertTrue(p1.remove(tasks[3]));
523		assertFalse(q.contains(tasks[3]));
524	<	} catch(Exception e) {
524	>	} catch (Exception e) {
525		unexpectedException();
526		} finally {
527		joinPool(p1);
#	Line 534 | Line 534 | public class ThreadPoolExecutorSubclassT
534		public void testPurge() {
535		ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
536		FutureTask[] tasks = new FutureTask[5];
537	<	for(int i = 0; i < 5; i++){
537	>	for (int i = 0; i < 5; i++) {
538		tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
539		p1.execute(tasks[i]);
540		}
#	Line 553 | Line 553 | public class ThreadPoolExecutorSubclassT
553		ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
554		List l;
555		try {
556	<	for(int i = 0; i < 5; i++)
556	>	for (int i = 0; i < 5; i++)
557		p1.execute(new MediumPossiblyInterruptedRunnable());
558		}
559		finally {
#	Line 577 | Line 577 | public class ThreadPoolExecutorSubclassT
577		new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
578		shouldThrow();
579		}
580	<	catch (IllegalArgumentException success){}
580	>	catch (IllegalArgumentException success) {}
581		}
582
583		/**
#	Line 588 | Line 588 | public class ThreadPoolExecutorSubclassT
588		new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
589		shouldThrow();
590		}
591	<	catch (IllegalArgumentException success){}
591	>	catch (IllegalArgumentException success) {}
592		}
593
594		/**
#	Line 599 | Line 599 | public class ThreadPoolExecutorSubclassT
599		new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
600		shouldThrow();
601		}
602	<	catch (IllegalArgumentException success){}
602	>	catch (IllegalArgumentException success) {}
603		}
604
605		/**
#	Line 610 | Line 610 | public class ThreadPoolExecutorSubclassT
610		new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
611		shouldThrow();
612		}
613	<	catch (IllegalArgumentException success){}
613	>	catch (IllegalArgumentException success) {}
614		}
615
616		/**
#	Line 621 | Line 621 | public class ThreadPoolExecutorSubclassT
621		new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
622		shouldThrow();
623		}
624	<	catch (IllegalArgumentException success){}
624	>	catch (IllegalArgumentException success) {}
625		}
626
627		/**
#	Line 632 | Line 632 | public class ThreadPoolExecutorSubclassT
632		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null);
633		shouldThrow();
634		}
635	<	catch (NullPointerException success){}
635	>	catch (NullPointerException success) {}
636		}
637
638
#	Line 644 | Line 644 | public class ThreadPoolExecutorSubclassT
644		try {
645		new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
646		shouldThrow();
647	<	} catch (IllegalArgumentException success){}
647	>	} catch (IllegalArgumentException success) {}
648		}
649
650		/**
#	Line 655 | Line 655 | public class ThreadPoolExecutorSubclassT
655		new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
656		shouldThrow();
657		}
658	<	catch (IllegalArgumentException success){}
658	>	catch (IllegalArgumentException success) {}
659		}
660
661		/**
#	Line 666 | Line 666 | public class ThreadPoolExecutorSubclassT
666		new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
667		shouldThrow();
668		}
669	<	catch (IllegalArgumentException success){}
669	>	catch (IllegalArgumentException success) {}
670		}
671
672		/**
#	Line 677 | Line 677 | public class ThreadPoolExecutorSubclassT
677		new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
678		shouldThrow();
679		}
680	<	catch (IllegalArgumentException success){}
680	>	catch (IllegalArgumentException success) {}
681		}
682
683		/**
#	Line 688 | Line 688 | public class ThreadPoolExecutorSubclassT
688		new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
689		shouldThrow();
690		}
691	<	catch (IllegalArgumentException success){}
691	>	catch (IllegalArgumentException success) {}
692		}
693
694		/**
#	Line 699 | Line 699 | public class ThreadPoolExecutorSubclassT
699		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory());
700		shouldThrow();
701		}
702	<	catch (NullPointerException success){}
702	>	catch (NullPointerException success) {}
703		}
704
705		/**
#	Line 711 | Line 711 | public class ThreadPoolExecutorSubclassT
711		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
712		shouldThrow();
713		}
714	<	catch (NullPointerException success){}
714	>	catch (NullPointerException success) {}
715		}
716
717
#	Line 723 | Line 723 | public class ThreadPoolExecutorSubclassT
723		new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
724		shouldThrow();
725		}
726	<	catch (IllegalArgumentException success){}
726	>	catch (IllegalArgumentException success) {}
727		}
728
729		/**
#	Line 734 | Line 734 | public class ThreadPoolExecutorSubclassT
734		new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
735		shouldThrow();
736		}
737	<	catch (IllegalArgumentException success){}
737	>	catch (IllegalArgumentException success) {}
738		}
739
740		/**
#	Line 745 | Line 745 | public class ThreadPoolExecutorSubclassT
745		new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
746		shouldThrow();
747		}
748	<	catch (IllegalArgumentException success){}
748	>	catch (IllegalArgumentException success) {}
749		}
750
751		/**
#	Line 756 | Line 756 | public class ThreadPoolExecutorSubclassT
756		new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
757		shouldThrow();
758		}
759	<	catch (IllegalArgumentException success){}
759	>	catch (IllegalArgumentException success) {}
760		}
761
762		/**
#	Line 767 | Line 767 | public class ThreadPoolExecutorSubclassT
767		new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
768		shouldThrow();
769		}
770	<	catch (IllegalArgumentException success){}
770	>	catch (IllegalArgumentException success) {}
771		}
772
773		/**
#	Line 778 | Line 778 | public class ThreadPoolExecutorSubclassT
778		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler());
779		shouldThrow();
780		}
781	<	catch (NullPointerException success){}
781	>	catch (NullPointerException success) {}
782		}
783
784		/**
#	Line 790 | Line 790 | public class ThreadPoolExecutorSubclassT
790		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
791		shouldThrow();
792		}
793	<	catch (NullPointerException success){}
793	>	catch (NullPointerException success) {}
794		}
795
796
#	Line 802 | Line 802 | public class ThreadPoolExecutorSubclassT
802		new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
803		shouldThrow();
804		}
805	<	catch (IllegalArgumentException success){}
805	>	catch (IllegalArgumentException success) {}
806		}
807
808		/**
#	Line 813 | Line 813 | public class ThreadPoolExecutorSubclassT
813		new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
814		shouldThrow();
815		}
816	<	catch (IllegalArgumentException success){}
816	>	catch (IllegalArgumentException success) {}
817		}
818
819		/**
#	Line 824 | Line 824 | public class ThreadPoolExecutorSubclassT
824		new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
825		shouldThrow();
826		}
827	<	catch (IllegalArgumentException success){}
827	>	catch (IllegalArgumentException success) {}
828		}
829
830		/**
#	Line 835 | Line 835 | public class ThreadPoolExecutorSubclassT
835		new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
836		shouldThrow();
837		}
838	<	catch (IllegalArgumentException success){}
838	>	catch (IllegalArgumentException success) {}
839		}
840
841		/**
#	Line 846 | Line 846 | public class ThreadPoolExecutorSubclassT
846		new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
847		shouldThrow();
848		}
849	<	catch (IllegalArgumentException success){}
849	>	catch (IllegalArgumentException success) {}
850		}
851
852		/**
#	Line 857 | Line 857 | public class ThreadPoolExecutorSubclassT
857		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
858		shouldThrow();
859		}
860	<	catch (NullPointerException success){}
860	>	catch (NullPointerException success) {}
861		}
862
863		/**
#	Line 869 | Line 869 | public class ThreadPoolExecutorSubclassT
869		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
870		shouldThrow();
871		}
872	<	catch (NullPointerException success){}
872	>	catch (NullPointerException success) {}
873		}
874
875		/**
#	Line 881 | Line 881 | public class ThreadPoolExecutorSubclassT
881		new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
882		shouldThrow();
883		}
884	<	catch (NullPointerException successdn8){}
884	>	catch (NullPointerException successdn8) {}
885		}
886
887
#	Line 893 | Line 893 | public class ThreadPoolExecutorSubclassT
893		ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
894		try {
895
896	<	for(int i = 0; i < 5; ++i){
896	>	for (int i = 0; i < 5; ++i) {
897		p.execute(new MediumRunnable());
898		}
899		shouldThrow();
900	<	} catch(RejectedExecutionException success){}
900	>	} catch (RejectedExecutionException success) {}
901		joinPool(p);
902		}
903
#	Line 910 | Line 910 | public class ThreadPoolExecutorSubclassT
910		try {
911
912		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
913	<	for(int i = 0; i < 5; ++i){
913	>	for (int i = 0; i < 5; ++i) {
914		tasks[i] = new TrackedNoOpRunnable();
915		}
916		TrackedLongRunnable mr = new TrackedLongRunnable();
917		p.execute(mr);
918	<	for(int i = 0; i < 5; ++i){
918	>	for (int i = 0; i < 5; ++i) {
919		p.execute(tasks[i]);
920		}
921	<	for(int i = 1; i < 5; ++i) {
921	>	for (int i = 1; i < 5; ++i) {
922		assertTrue(tasks[i].done);
923		}
924	<	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
925	<	} catch(RejectedExecutionException ex){
924	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
925	>	} catch (RejectedExecutionException ex) {
926		unexpectedException();
927		} finally {
928		joinPool(p);
#	Line 938 | Line 938 | public class ThreadPoolExecutorSubclassT
938		try {
939
940		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
941	<	for(int i = 0; i < 5; ++i){
941	>	for (int i = 0; i < 5; ++i) {
942		tasks[i] = new TrackedNoOpRunnable();
943		}
944		p.execute(new TrackedLongRunnable());
945	<	for(int i = 0; i < 5; ++i){
945	>	for (int i = 0; i < 5; ++i) {
946		p.execute(tasks[i]);
947		}
948	<	for(int i = 0; i < 5; ++i){
948	>	for (int i = 0; i < 5; ++i) {
949		assertFalse(tasks[i].done);
950		}
951	<	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
952	<	} catch(RejectedExecutionException ex){
951	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
952	>	} catch (RejectedExecutionException ex) {
953		unexpectedException();
954		} finally {
955		joinPool(p);
#	Line 971 | Line 971 | public class ThreadPoolExecutorSubclassT
971		p.execute(r3);
972		assertFalse(p.getQueue().contains(r2));
973		assertTrue(p.getQueue().contains(r3));
974	<	try { p.shutdownNow(); } catch(SecurityException ok) { return; }
975	<	} catch(RejectedExecutionException ex){
974	>	try { p.shutdownNow(); } catch (SecurityException ok) { return; }
975	>	} catch (RejectedExecutionException ex) {
976		unexpectedException();
977		} finally {
978		joinPool(p);
#	Line 985 | Line 985 | public class ThreadPoolExecutorSubclassT
985		public void testRejectedExecutionExceptionOnShutdown() {
986		ThreadPoolExecutor tpe =
987		new CustomTPE(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
988	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
988	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
989		try {
990		tpe.execute(new NoOpRunnable());
991		shouldThrow();
992	<	} catch(RejectedExecutionException success){}
992	>	} catch (RejectedExecutionException success) {}
993
994		joinPool(tpe);
995		}
#	Line 1001 | Line 1001 | public class ThreadPoolExecutorSubclassT
1001		RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
1002		ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1003
1004	<	try { p.shutdown(); } catch(SecurityException ok) { return; }
1004	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1005		try {
1006		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1007		p.execute(r);
1008		assertFalse(r.done);
1009	<	} catch(RejectedExecutionException success){
1009	>	} catch (RejectedExecutionException success) {
1010		unexpectedException();
1011		} finally {
1012		joinPool(p);
#	Line 1020 | Line 1020 | public class ThreadPoolExecutorSubclassT
1020		RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
1021		ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1022
1023	<	try { p.shutdown(); } catch(SecurityException ok) { return; }
1023	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1024		try {
1025		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1026		p.execute(r);
1027		assertFalse(r.done);
1028	<	} catch(RejectedExecutionException success){
1028	>	} catch (RejectedExecutionException success) {
1029		unexpectedException();
1030		} finally {
1031		joinPool(p);
#	Line 1040 | Line 1040 | public class ThreadPoolExecutorSubclassT
1040		RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
1041		ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1042
1043	<	try { p.shutdown(); } catch(SecurityException ok) { return; }
1043	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1044		try {
1045		TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1046		p.execute(r);
1047		assertFalse(r.done);
1048	<	} catch(RejectedExecutionException success){
1048	>	} catch (RejectedExecutionException success) {
1049		unexpectedException();
1050		} finally {
1051		joinPool(p);
#	Line 1062 | Line 1062 | public class ThreadPoolExecutorSubclassT
1062		tpe = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1063		tpe.execute(null);
1064		shouldThrow();
1065	<	} catch(NullPointerException success){}
1065	>	} catch (NullPointerException success) {}
1066
1067		joinPool(tpe);
1068		}
#	Line 1074 | Line 1074 | public class ThreadPoolExecutorSubclassT
1074		ThreadPoolExecutor tpe = null;
1075		try {
1076		tpe = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1077	<	} catch(Exception e){}
1077	>	} catch (Exception e) {}
1078		try {
1079		tpe.setCorePoolSize(-1);
1080		shouldThrow();
1081	<	} catch(IllegalArgumentException success){
1081	>	} catch (IllegalArgumentException success) {
1082		} finally {
1083	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1083	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1084		}
1085		joinPool(tpe);
1086		}
#	Line 1093 | Line 1093 | public class ThreadPoolExecutorSubclassT
1093		ThreadPoolExecutor tpe = null;
1094		try {
1095		tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1096	<	} catch(Exception e){}
1096	>	} catch (Exception e) {}
1097		try {
1098		tpe.setMaximumPoolSize(1);
1099		shouldThrow();
1100	<	} catch(IllegalArgumentException success){
1100	>	} catch (IllegalArgumentException success) {
1101		} finally {
1102	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1102	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1103		}
1104		joinPool(tpe);
1105		}
#	Line 1112 | Line 1112 | public class ThreadPoolExecutorSubclassT
1112		ThreadPoolExecutor tpe = null;
1113		try {
1114		tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1115	<	} catch(Exception e){}
1115	>	} catch (Exception e) {}
1116		try {
1117		tpe.setMaximumPoolSize(-1);
1118		shouldThrow();
1119	<	} catch(IllegalArgumentException success){
1119	>	} catch (IllegalArgumentException success) {
1120		} finally {
1121	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1121	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1122		}
1123		joinPool(tpe);
1124		}
#	Line 1132 | Line 1132 | public class ThreadPoolExecutorSubclassT
1132		ThreadPoolExecutor tpe = null;
1133		try {
1134		tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1135	<	} catch(Exception e){}
1135	>	} catch (Exception e) {}
1136
1137		try {
1138		tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
1139		shouldThrow();
1140	<	} catch(IllegalArgumentException success){
1140	>	} catch (IllegalArgumentException success) {
1141		} finally {
1142	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1142	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1143		}
1144		joinPool(tpe);
1145		}
#	Line 1149 | Line 1149 | public class ThreadPoolExecutorSubclassT
1149		*/
1150		public void testTerminated() {
1151		CustomTPE tpe = new CustomTPE();
1152	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1152	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1153		assertTrue(tpe.terminatedCalled);
1154		joinPool(tpe);
1155		}
#	Line 1166 | Line 1166 | public class ThreadPoolExecutorSubclassT
1166		assertTrue(r.done);
1167		assertTrue(tpe.beforeCalled);
1168		assertTrue(tpe.afterCalled);
1169	<	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1169	>	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1170		}
1171	<	catch(Exception ex) {
1171	>	catch (Exception ex) {
1172		unexpectedException();
1173		} finally {
1174		joinPool(tpe);
#	Line 1247 | Line 1247 | public class ThreadPoolExecutorSubclassT
1247		try {
1248		e.invokeAny(null);
1249		} catch (NullPointerException success) {
1250	<	} catch(Exception ex) {
1250	>	} catch (Exception ex) {
1251		unexpectedException();
1252		} finally {
1253		joinPool(e);
#	Line 1262 | Line 1262 | public class ThreadPoolExecutorSubclassT
1262		try {
1263		e.invokeAny(new ArrayList<Callable<String>>());
1264		} catch (IllegalArgumentException success) {
1265	<	} catch(Exception ex) {
1265	>	} catch (Exception ex) {
1266		unexpectedException();
1267		} finally {
1268		joinPool(e);
#	Line 1280 | Line 1280 | public class ThreadPoolExecutorSubclassT
1280		l.add(null);
1281		e.invokeAny(l);
1282		} catch (NullPointerException success) {
1283	<	} catch(Exception ex) {
1283	>	} catch (Exception ex) {
1284		unexpectedException();
1285		} finally {
1286		joinPool(e);
#	Line 1297 | Line 1297 | public class ThreadPoolExecutorSubclassT
1297		l.add(new NPETask());
1298		e.invokeAny(l);
1299		} catch (ExecutionException success) {
1300	<	} catch(Exception ex) {
1300	>	} catch (Exception ex) {
1301		unexpectedException();
1302		} finally {
1303		joinPool(e);
#	Line 1316 | Line 1316 | public class ThreadPoolExecutorSubclassT
1316		String result = e.invokeAny(l);
1317		assertSame(TEST_STRING, result);
1318		} catch (ExecutionException success) {
1319	<	} catch(Exception ex) {
1319	>	} catch (Exception ex) {
1320		unexpectedException();
1321		} finally {
1322		joinPool(e);
#	Line 1331 | Line 1331 | public class ThreadPoolExecutorSubclassT
1331		try {
1332		e.invokeAll(null);
1333		} catch (NullPointerException success) {
1334	<	} catch(Exception ex) {
1334	>	} catch (Exception ex) {
1335		unexpectedException();
1336		} finally {
1337		joinPool(e);
#	Line 1346 | Line 1346 | public class ThreadPoolExecutorSubclassT
1346		try {
1347		List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1348		assertTrue(r.isEmpty());
1349	<	} catch(Exception ex) {
1349	>	} catch (Exception ex) {
1350		unexpectedException();
1351		} finally {
1352		joinPool(e);
#	Line 1364 | Line 1364 | public class ThreadPoolExecutorSubclassT
1364		l.add(null);
1365		e.invokeAll(l);
1366		} catch (NullPointerException success) {
1367	<	} catch(Exception ex) {
1367	>	} catch (Exception ex) {
1368		unexpectedException();
1369		} finally {
1370		joinPool(e);
#	Line 1383 | Line 1383 | public class ThreadPoolExecutorSubclassT
1383		assertEquals(1, result.size());
1384		for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1385		it.next().get();
1386	<	} catch(ExecutionException success) {
1387	<	} catch(Exception ex) {
1386	>	} catch (ExecutionException success) {
1387	>	} catch (Exception ex) {
1388		unexpectedException();
1389		} finally {
1390		joinPool(e);
#	Line 1405 | Line 1405 | public class ThreadPoolExecutorSubclassT
1405		for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1406		assertSame(TEST_STRING, it.next().get());
1407		} catch (ExecutionException success) {
1408	<	} catch(Exception ex) {
1408	>	} catch (Exception ex) {
1409		unexpectedException();
1410		} finally {
1411		joinPool(e);
#	Line 1422 | Line 1422 | public class ThreadPoolExecutorSubclassT
1422		try {
1423		e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1424		} catch (NullPointerException success) {
1425	<	} catch(Exception ex) {
1425	>	} catch (Exception ex) {
1426		unexpectedException();
1427		} finally {
1428		joinPool(e);
#	Line 1439 | Line 1439 | public class ThreadPoolExecutorSubclassT
1439		l.add(new StringTask());
1440		e.invokeAny(l, MEDIUM_DELAY_MS, null);
1441		} catch (NullPointerException success) {
1442	<	} catch(Exception ex) {
1442	>	} catch (Exception ex) {
1443		unexpectedException();
1444		} finally {
1445		joinPool(e);
#	Line 1454 | Line 1454 | public class ThreadPoolExecutorSubclassT
1454		try {
1455		e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1456		} catch (IllegalArgumentException success) {
1457	<	} catch(Exception ex) {
1457	>	} catch (Exception ex) {
1458		unexpectedException();
1459		} finally {
1460		joinPool(e);
#	Line 1472 | Line 1472 | public class ThreadPoolExecutorSubclassT
1472		l.add(null);
1473		e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1474		} catch (NullPointerException success) {
1475	<	} catch(Exception ex) {
1475	>	} catch (Exception ex) {
1476		ex.printStackTrace();
1477		unexpectedException();
1478		} finally {
#	Line 1489 | Line 1489 | public class ThreadPoolExecutorSubclassT
1489		ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1490		l.add(new NPETask());
1491		e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1492	<	} catch(ExecutionException success) {
1493	<	} catch(Exception ex) {
1492	>	} catch (ExecutionException success) {
1493	>	} catch (Exception ex) {
1494		unexpectedException();
1495		} finally {
1496		joinPool(e);
#	Line 1509 | Line 1509 | public class ThreadPoolExecutorSubclassT
1509		String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1510		assertSame(TEST_STRING, result);
1511		} catch (ExecutionException success) {
1512	<	} catch(Exception ex) {
1512	>	} catch (Exception ex) {
1513		unexpectedException();
1514		} finally {
1515		joinPool(e);
#	Line 1524 | Line 1524 | public class ThreadPoolExecutorSubclassT
1524		try {
1525		e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1526		} catch (NullPointerException success) {
1527	<	} catch(Exception ex) {
1527	>	} catch (Exception ex) {
1528		unexpectedException();
1529		} finally {
1530		joinPool(e);
#	Line 1541 | Line 1541 | public class ThreadPoolExecutorSubclassT
1541		l.add(new StringTask());
1542		e.invokeAll(l, MEDIUM_DELAY_MS, null);
1543		} catch (NullPointerException success) {
1544	<	} catch(Exception ex) {
1544	>	} catch (Exception ex) {
1545		unexpectedException();
1546		} finally {
1547		joinPool(e);
#	Line 1556 | Line 1556 | public class ThreadPoolExecutorSubclassT
1556		try {
1557		List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1558		assertTrue(r.isEmpty());
1559	<	} catch(Exception ex) {
1559	>	} catch (Exception ex) {
1560		unexpectedException();
1561		} finally {
1562		joinPool(e);
#	Line 1574 | Line 1574 | public class ThreadPoolExecutorSubclassT
1574		l.add(null);
1575		e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1576		} catch (NullPointerException success) {
1577	<	} catch(Exception ex) {
1577	>	} catch (Exception ex) {
1578		unexpectedException();
1579		} finally {
1580		joinPool(e);
#	Line 1593 | Line 1593 | public class ThreadPoolExecutorSubclassT
1593		assertEquals(1, result.size());
1594		for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1595		it.next().get();
1596	<	} catch(ExecutionException success) {
1597	<	} catch(Exception ex) {
1596	>	} catch (ExecutionException success) {
1597	>	} catch (Exception ex) {
1598		unexpectedException();
1599		} finally {
1600		joinPool(e);
#	Line 1615 | Line 1615 | public class ThreadPoolExecutorSubclassT
1615		for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1616		assertSame(TEST_STRING, it.next().get());
1617		} catch (ExecutionException success) {
1618	<	} catch(Exception ex) {
1618	>	} catch (Exception ex) {
1619		unexpectedException();
1620		} finally {
1621		joinPool(e);
#	Line 1643 | Line 1643 | public class ThreadPoolExecutorSubclassT
1643		assertTrue(f3.isDone());
1644		assertFalse(f1.isCancelled());
1645		assertTrue(f2.isCancelled());
1646	<	} catch(Exception ex) {
1646	>	} catch (Exception ex) {
1647		unexpectedException();
1648		} finally {
1649		joinPool(e);
#	Line 1662 | Line 1662 | public class ThreadPoolExecutorSubclassT
1662		e.execute(new NoOpRunnable());
1663		}
1664		Thread.sleep(LONG_DELAY_MS);
1665	<	} catch(Exception ex) {
1665	>	} catch (Exception ex) {
1666		unexpectedException();
1667		} finally {
1668		joinPool(e);
#	Line 1688 | Line 1688 | public class ThreadPoolExecutorSubclassT
1688		try {
1689		Thread.sleep(MEDIUM_DELAY_MS);
1690		assertEquals(0, tpe.getPoolSize());
1691	<	} catch(InterruptedException e){
1691	>	} catch (InterruptedException e) {
1692		unexpectedException();
1693		} finally {
1694		joinPool(tpe);
#	Line 1705 | Line 1705 | public class ThreadPoolExecutorSubclassT
1705		try {
1706		Thread.sleep(MEDIUM_DELAY_MS);
1707		assertTrue(tpe.getPoolSize() >= 1);
1708	<	} catch(InterruptedException e){
1708	>	} catch (InterruptedException e) {
1709		unexpectedException();
1710		} finally {
1711		joinPool(tpe);

Diff Legend

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