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.63 by jsr166, Sun Oct 4 02:07:32 2015 UTC vs.
Revision 1.68 by jsr166, Sun Oct 4 02:26:47 2015 UTC

#	Line 252 | Line 252 | public class ThreadPoolExecutorSubclassT
252		new CustomTPE(2, 2,
253		LONG_DELAY_MS, MILLISECONDS,
254		new ArrayBlockingQueue<Runnable>(10));
255	–	final CountDownLatch threadStarted = new CountDownLatch(1);
256	–	final CountDownLatch done = new CountDownLatch(1);
255		try (PoolCleaner cleaner = cleaner(p)) {
256	+	final CountDownLatch threadStarted = new CountDownLatch(1);
257	+	final CountDownLatch done = new CountDownLatch(1);
258		assertEquals(0, p.getActiveCount());
259		p.execute(new CheckedRunnable() {
260		public void realRun() throws InterruptedException {
#	Line 262 | Line 262 | public class ThreadPoolExecutorSubclassT
262		assertEquals(1, p.getActiveCount());
263		done.await();
264		}});
265	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
265	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
266		assertEquals(1, p.getActiveCount());
267		done.countDown();
268		}
#	Line 525 | Line 525 | public class ThreadPoolExecutorSubclassT
525		new CustomTPE(1, 1,
526		LONG_DELAY_MS, MILLISECONDS,
527		new ArrayBlockingQueue<Runnable>(10));
528	<	final CountDownLatch threadStarted = new CountDownLatch(1);
529	<	final CountDownLatch done = new CountDownLatch(1);
530	<	try {
528	>	try (PoolCleaner cleaner = cleaner(p)) {
529	>	final CountDownLatch threadStarted = new CountDownLatch(1);
530	>	final CountDownLatch done = new CountDownLatch(1);
531		assertEquals(0, p.getPoolSize());
532		p.execute(new CheckedRunnable() {
533		public void realRun() throws InterruptedException {
#	Line 535 | Line 535 | public class ThreadPoolExecutorSubclassT
535		assertEquals(1, p.getPoolSize());
536		done.await();
537		}});
538	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
538	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
539		assertEquals(1, p.getPoolSize());
540	<	} finally {
541	<	done.countDown();
542	<	joinPool(p);
540	>	done.countDown();   // release pool
541		}
542		}
543
#	Line 551 | Line 549 | public class ThreadPoolExecutorSubclassT
549		new CustomTPE(1, 1,
550		LONG_DELAY_MS, MILLISECONDS,
551		new ArrayBlockingQueue<Runnable>(10));
552	<	final CountDownLatch threadStarted = new CountDownLatch(1);
553	<	final CountDownLatch done = new CountDownLatch(1);
554	<	try {
552	>	try (PoolCleaner cleaner = cleaner(p)) {
553	>	final CountDownLatch threadStarted = new CountDownLatch(1);
554	>	final CountDownLatch done = new CountDownLatch(1);
555		assertEquals(0, p.getTaskCount());
556		p.execute(new CheckedRunnable() {
557		public void realRun() throws InterruptedException {
#	Line 561 | Line 559 | public class ThreadPoolExecutorSubclassT
559		assertEquals(1, p.getTaskCount());
560		done.await();
561		}});
562	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
562	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
563		assertEquals(1, p.getTaskCount());
566	–	} finally {
564		done.countDown();
568	–	joinPool(p);
565		}
566		}
567
#	Line 573 | Line 569 | public class ThreadPoolExecutorSubclassT
569		* isShutdown is false before shutdown, true after
570		*/
571		public void testIsShutdown() {
572	<
573	<	ThreadPoolExecutor p = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
574	<	assertFalse(p.isShutdown());
575	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
576	<	assertTrue(p.isShutdown());
577	<	joinPool(p);
572	>	final ThreadPoolExecutor p =
573	>	new CustomTPE(1, 1,
574	>	LONG_DELAY_MS, MILLISECONDS,
575	>	new ArrayBlockingQueue<Runnable>(10));
576	>	try (PoolCleaner cleaner = cleaner(p)) {
577	>	assertFalse(p.isShutdown());
578	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
579	>	assertTrue(p.isShutdown());
580	>	}
581		}
582
583		/**
#	Line 599 | Line 598 | public class ThreadPoolExecutorSubclassT
598		threadStarted.countDown();
599		done.await();
600		}});
601	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
601	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
602		assertFalse(p.isTerminating());
603		done.countDown();
604		} finally {
#	Line 628 | Line 627 | public class ThreadPoolExecutorSubclassT
627		threadStarted.countDown();
628		done.await();
629		}});
630	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
630	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
631		assertFalse(p.isTerminating());
632		done.countDown();
633		} finally {
#	Line 663 | Line 662 | public class ThreadPoolExecutorSubclassT
662		tasks[i] = new FutureTask(task);
663		p.execute(tasks[i]);
664		}
665	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
665	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
666		assertSame(q, p.getQueue());
667		assertFalse(q.contains(tasks[0]));
668		assertTrue(q.contains(tasks[tasks.length - 1]));
#	Line 695 | Line 694 | public class ThreadPoolExecutorSubclassT
694		}};
695		p.execute(tasks[i]);
696		}
697	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
697	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
698		assertFalse(p.remove(tasks[0]));
699		assertTrue(q.contains(tasks[4]));
700		assertTrue(q.contains(tasks[3]));
#	Line 734 | Line 733 | public class ThreadPoolExecutorSubclassT
733		tasks[i] = new FutureTask(task);
734		p.execute(tasks[i]);
735		}
736	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
736	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
737		assertEquals(tasks.length, p.getTaskCount());
738		assertEquals(tasks.length - 1, q.size());
739		assertEquals(1L, p.getActiveCount());

Diff Legend

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