ViewVC Help

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

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

Comparing jsr166/src/test/tck/JSR166TestCase.java (file contents):
Revision 1.154 by jsr166, Sat Oct 3 19:39:16 2015 UTC vs.
Revision 1.158 by jsr166, Sat Oct 3 23:17:03 2015 UTC

#	Line 7 | Line 7
7		*/
8
9		import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	+	import static java.util.concurrent.TimeUnit.MINUTES;
11		import static java.util.concurrent.TimeUnit.NANOSECONDS;
12
13		import java.io.ByteArrayInputStream;
#	Line 187 | Line 188 | public class JSR166TestCase extends Test
188		return (regex == null) ? null : Pattern.compile(regex);
189		}
190
191	+	static volatile TestCase currentTestCase;
192	+	static {
193	+	Runnable checkForWedgedTest = new Runnable() { public void run() {
194	+	// avoid spurious reports with enormous runsPerTest
195	+	final int timeoutMinutes = Math.max(runsPerTest / 10, 1);
196	+	for (TestCase lastTestCase = currentTestCase;;) {
197	+	try { MINUTES.sleep(timeoutMinutes); }
198	+	catch (InterruptedException unexpected) { break; }
199	+	if (lastTestCase == currentTestCase) {
200	+	System.err.println
201	+	("Looks like we're stuck running test: "
202	+	+ lastTestCase);
203	+	dumpTestThreads();
204	+	}
205	+	lastTestCase = currentTestCase;
206	+	}}};
207	+	Thread thread = new Thread(checkForWedgedTest, "checkForWedgedTest");
208	+	thread.setDaemon(true);
209	+	thread.start();
210	+	}
211	+
212		public void runBare() throws Throwable {
213	+	currentTestCase = this;
214		if (methodFilter == null
215		|| methodFilter.matcher(toString()).find())
216		super.runBare();
#	Line 461 | Line 484 | public class JSR166TestCase extends Test
484		} else {
485		return new TestSuite();
486		}
464	–
487		}
488
489		// Delays for timing-dependent tests, in milliseconds.
#	Line 519 | Line 541 | public class JSR166TestCase extends Test
541		* the same test have no effect.
542		*/
543		public void threadRecordFailure(Throwable t) {
544	<	threadDump();
544	>	System.err.println(t);
545	>	dumpTestThreads();
546		threadFailure.compareAndSet(null, t);
547		}
548
#	Line 530 | Line 553 | public class JSR166TestCase extends Test
553		void tearDownFail(String format, Object... args) {
554		String msg = toString() + ": " + String.format(format, args);
555		System.err.println(msg);
556	<	threadDump();
556	>	dumpTestThreads();
557		throw new AssertionFailedError(msg);
558		}
559
#	Line 747 | Line 770 | public class JSR166TestCase extends Test
770		/**
771		* Allows use of try-with-resources with per-test thread pools.
772		*/
773	<	static class PoolCloser<T extends ExecutorService>
773	>	class PoolCloser<T extends ExecutorService>
774		implements AutoCloseable {
775		public final T pool;
776		public PoolCloser(T pool) { this.pool = pool; }
#	Line 757 | Line 780 | public class JSR166TestCase extends Test
780		/**
781		* Waits out termination of a thread pool or fails doing so.
782		*/
783	<	static void joinPool(ExecutorService pool) {
783	>	void joinPool(ExecutorService pool) {
784		try {
785		pool.shutdown();
786	<	if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
787	<	fail("ExecutorService " + pool +
788	<	" did not terminate in a timely manner");
786	>	if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS)) {
787	>	try {
788	>	threadFail("ExecutorService " + pool +
789	>	" did not terminate in a timely manner");
790	>	} finally {
791	>	// last resort, for the benefit of subsequent tests
792	>	pool.shutdownNow();
793	>	pool.awaitTermination(SMALL_DELAY_MS, MILLISECONDS);
794	>	}
795	>	}
796		} catch (SecurityException ok) {
797		// Allowed in case test doesn't have privs
798		} catch (InterruptedException fail) {
799	<	fail("Unexpected InterruptedException");
799	>	threadFail("Unexpected InterruptedException");
800		}
801		}
802
#	Line 798 | Line 828 | public class JSR166TestCase extends Test
828		}
829
830		/**
831	<	* A debugging tool to print all stack traces, as jstack does.
831	>	* A debugging tool to print stack traces of most threads, as jstack does.
832		* Uninteresting threads are filtered out.
833		*/
834	<	static void threadDump() {
834	>	static void dumpTestThreads() {
835		ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
836		System.err.println("------ stacktrace dump start ------");
837		for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
#	Line 814 | Line 844 | public class JSR166TestCase extends Test
844		if ("Finalizer".equals(name)
845		&& info.getLockName().startsWith("java.lang.ref.ReferenceQueue$Lock"))
846		continue;
847	+	if ("checkForWedgedTest".equals(name))
848	+	continue;
849		System.err.print(info);
850		}
851		System.err.println("------ stacktrace dump end ------");
#	Line 836 | Line 868 | public class JSR166TestCase extends Test
868		delay(millis);
869		assertTrue(thread.isAlive());
870		} catch (InterruptedException fail) {
871	<	fail("Unexpected InterruptedException");
871	>	threadFail("Unexpected InterruptedException");
872		}
873		}
874
#	Line 858 | Line 890 | public class JSR166TestCase extends Test
890		for (Thread thread : threads)
891		assertTrue(thread.isAlive());
892		} catch (InterruptedException fail) {
893	<	fail("Unexpected InterruptedException");
893	>	threadFail("Unexpected InterruptedException");
894		}
895		}
896

Diff Legend

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