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.64 by jsr166, Sun Oct 4 02:09:57 2015 UTC vs.
Revision 1.69 by jsr166, Sun Oct 4 02:29:46 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 549 | 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 559 | 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());
564	–	} finally {
564		done.countDown();
566	–	joinPool(p);
565		}
566		}
567
#	Line 571 | 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 587 | Line 588 | public class ThreadPoolExecutorSubclassT
588		new CustomTPE(1, 1,
589		LONG_DELAY_MS, MILLISECONDS,
590		new ArrayBlockingQueue<Runnable>(10));
591	<	final CountDownLatch threadStarted = new CountDownLatch(1);
592	<	final CountDownLatch done = new CountDownLatch(1);
593	<	try {
591	>	try (PoolCleaner cleaner = cleaner(p)) {
592	>	final CountDownLatch threadStarted = new CountDownLatch(1);
593	>	final CountDownLatch done = new CountDownLatch(1);
594		assertFalse(p.isTerminating());
595		p.execute(new CheckedRunnable() {
596		public void realRun() throws InterruptedException {
#	Line 597 | 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();
603	–	} finally {
604		try { p.shutdown(); } catch (SecurityException ok) { return; }
605	+	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
606	+	assertTrue(p.isTerminated());
607	+	assertFalse(p.isTerminating());
608		}
606	–	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
607	–	assertTrue(p.isTerminated());
608	–	assertFalse(p.isTerminating());
609		}
610
611		/**
#	Line 626 | Line 626 | public class ThreadPoolExecutorSubclassT
626		threadStarted.countDown();
627		done.await();
628		}});
629	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
629	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
630		assertFalse(p.isTerminating());
631		done.countDown();
632		} finally {
#	Line 661 | Line 661 | public class ThreadPoolExecutorSubclassT
661		tasks[i] = new FutureTask(task);
662		p.execute(tasks[i]);
663		}
664	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
664	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
665		assertSame(q, p.getQueue());
666		assertFalse(q.contains(tasks[0]));
667		assertTrue(q.contains(tasks[tasks.length - 1]));
#	Line 693 | Line 693 | public class ThreadPoolExecutorSubclassT
693		}};
694		p.execute(tasks[i]);
695		}
696	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
696	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
697		assertFalse(p.remove(tasks[0]));
698		assertTrue(q.contains(tasks[4]));
699		assertTrue(q.contains(tasks[3]));
#	Line 732 | Line 732 | public class ThreadPoolExecutorSubclassT
732		tasks[i] = new FutureTask(task);
733		p.execute(tasks[i]);
734		}
735	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
735	>	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
736		assertEquals(tasks.length, p.getTaskCount());
737		assertEquals(tasks.length - 1, q.size());
738		assertEquals(1L, p.getActiveCount());

Diff Legend

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