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.159 by jsr166, Sun Oct 4 00:30:50 2015 UTC vs.
Revision 1.180 by jsr166, Mon Nov 9 05:43:39 2015 UTC

#	Line 20 | Line 20 | import java.lang.management.ThreadMXBean
20		import java.lang.reflect.Constructor;
21		import java.lang.reflect.Method;
22		import java.lang.reflect.Modifier;
23	+	import java.nio.file.Files;
24	+	import java.nio.file.Paths;
25		import java.security.CodeSource;
26		import java.security.Permission;
27		import java.security.PermissionCollection;
#	Line 52 | Line 54 | import java.util.concurrent.ThreadFactor
54		import java.util.concurrent.ThreadPoolExecutor;
55		import java.util.concurrent.TimeoutException;
56		import java.util.concurrent.atomic.AtomicReference;
57	+	import java.util.regex.Matcher;
58		import java.util.regex.Pattern;
59
60		import junit.framework.AssertionFailedError;
#	Line 109 | Line 112 | import junit.framework.TestSuite;
112		* methods as there are exceptions the method can throw. Sometimes
113		* there are multiple tests per JSR166 method when the different
114		* "normal" behaviors differ significantly. And sometimes testcases
115	<	* cover multiple methods when they cannot be tested in
113	<	* isolation.
115	>	* cover multiple methods when they cannot be tested in isolation.
116		*
117		* <li>The documentation style for testcases is to provide as javadoc
118		* a simple sentence or two describing the property that the testcase
#	Line 188 | Line 190 | public class JSR166TestCase extends Test
190		return (regex == null) ? null : Pattern.compile(regex);
191		}
192
193	+	// Instrumentation to debug very rare, but very annoying hung test runs.
194		static volatile TestCase currentTestCase;
195	+	// static volatile int currentRun = 0;
196		static {
197		Runnable checkForWedgedTest = new Runnable() { public void run() {
198	<	// avoid spurious reports with enormous runsPerTest
199	<	final int timeoutMinutes = Math.max(runsPerTest / 10, 1);
198	>	// Avoid spurious reports with enormous runsPerTest.
199	>	// A single test case run should never take more than 1 second.
200	>	// But let's cap it at the high end too ...
201	>	final int timeoutMinutes =
202	>	Math.min(15, Math.max(runsPerTest / 60, 1));
203		for (TestCase lastTestCase = currentTestCase;;) {
204		try { MINUTES.sleep(timeoutMinutes); }
205		catch (InterruptedException unexpected) { break; }
206		if (lastTestCase == currentTestCase) {
207	<	System.err.println
208	<	("Looks like we're stuck running test: "
209	<	+ lastTestCase);
207	>	System.err.printf(
208	>	"Looks like we're stuck running test: %s%n",
209	>	lastTestCase);
210	>	//                     System.err.printf(
211	>	//                         "Looks like we're stuck running test: %s (%d/%d)%n",
212	>	//                         lastTestCase, currentRun, runsPerTest);
213	>	//                     System.err.println("availableProcessors=" +
214	>	//                         Runtime.getRuntime().availableProcessors());
215	>	//                     System.err.printf("cpu model = %s%n", cpuModel());
216		dumpTestThreads();
217	+	// one stack dump is probably enough; more would be spam
218	+	break;
219		}
220		lastTestCase = currentTestCase;
221		}}};
#	Line 209 | Line 224 | public class JSR166TestCase extends Test
224		thread.start();
225		}
226
227	+	//     public static String cpuModel() {
228	+	//         try {
229	+	//             Matcher matcher = Pattern.compile("model name\\s*: (.*)")
230	+	//                 .matcher(new String(
231	+	//                      Files.readAllBytes(Paths.get("/proc/cpuinfo")), "UTF-8"));
232	+	//             matcher.find();
233	+	//             return matcher.group(1);
234	+	//         } catch (Exception ex) { return null; }
235	+	//     }
236	+
237		public void runBare() throws Throwable {
238		currentTestCase = this;
239		if (methodFilter == null
#	Line 218 | Line 243 | public class JSR166TestCase extends Test
243
244		protected void runTest() throws Throwable {
245		for (int i = 0; i < runsPerTest; i++) {
246	+	// currentRun = i;
247		if (profileTests)
248		runTestProfiled();
249		else
#	Line 246 | Line 272 | public class JSR166TestCase extends Test
272		main(suite(), args);
273		}
274
275	+	static class PithyResultPrinter extends junit.textui.ResultPrinter {
276	+	PithyResultPrinter(java.io.PrintStream writer) { super(writer); }
277	+	long runTime;
278	+	public void startTest(Test test) {}
279	+	protected void printHeader(long runTime) {
280	+	this.runTime = runTime; // defer printing for later
281	+	}
282	+	protected void printFooter(TestResult result) {
283	+	if (result.wasSuccessful()) {
284	+	getWriter().println("OK (" + result.runCount() + " tests)"
285	+	+ "  Time: " + elapsedTimeAsString(runTime));
286	+	} else {
287	+	getWriter().println("Time: " + elapsedTimeAsString(runTime));
288	+	super.printFooter(result);
289	+	}
290	+	}
291	+	}
292	+
293	+	/**
294	+	* Returns a TestRunner that doesn't bother with unnecessary
295	+	* fluff, like printing a "." for each test case.
296	+	*/
297	+	static junit.textui.TestRunner newPithyTestRunner() {
298	+	junit.textui.TestRunner runner = new junit.textui.TestRunner();
299	+	runner.setPrinter(new PithyResultPrinter(System.out));
300	+	return runner;
301	+	}
302	+
303		/**
304		* Runs all unit tests in the given test suite.
305		* Actual behavior influenced by jsr166.* system properties.
#	Line 257 | Line 311 | public class JSR166TestCase extends Test
311		System.setSecurityManager(new SecurityManager());
312		}
313		for (int i = 0; i < suiteRuns; i++) {
314	<	TestResult result = junit.textui.TestRunner.run(suite);
314	>	TestResult result = newPithyTestRunner().doRun(suite);
315		if (!result.wasSuccessful())
316		System.exit(1);
317		System.gc();
#	Line 590 | Line 644 | public class JSR166TestCase extends Test
644		}
645
646		/**
647	<	* Finds missing try { ... } finally { joinPool(e); }
647	>	* Finds missing PoolCleaners
648		*/
649		void checkForkJoinPoolThreadLeaks() throws InterruptedException {
650		Thread[] survivors = new Thread[7];
#	Line 749 | Line 803 | public class JSR166TestCase extends Test
803		/**
804		* Delays, via Thread.sleep, for the given millisecond delay, but
805		* if the sleep is shorter than specified, may re-sleep or yield
806	<	* until time elapses.
806	>	* until time elapses.  Ensures that the given time, as measured
807	>	* by System.nanoTime(), has elapsed.
808		*/
809		static void delay(long millis) throws InterruptedException {
810	<	long startTime = System.nanoTime();
811	<	long ns = millis * 1000 * 1000;
812	<	for (;;) {
810	>	long nanos = millis * (1000 * 1000);
811	>	final long wakeupTime = System.nanoTime() + nanos;
812	>	do {
813		if (millis > 0L)
814		Thread.sleep(millis);
815		else // too short to sleep
816		Thread.yield();
817	<	long d = ns - (System.nanoTime() - startTime);
818	<	if (d > 0L)
819	<	millis = d / (1000 * 1000);
765	<	else
766	<	break;
767	<	}
817	>	nanos = wakeupTime - System.nanoTime();
818	>	millis = nanos / (1000 * 1000);
819	>	} while (nanos >= 0L);
820		}
821
822		/**
823		* Allows use of try-with-resources with per-test thread pools.
824		*/
825	<	class PoolCleaner<T extends ExecutorService>
826	<	implements AutoCloseable {
827	<	public final T pool;
776	<	public PoolCleaner(T pool) { this.pool = pool; }
825	>	class PoolCleaner implements AutoCloseable {
826	>	private final ExecutorService pool;
827	>	public PoolCleaner(ExecutorService pool) { this.pool = pool; }
828		public void close() { joinPool(pool); }
829		}
830
831	<	<T extends ExecutorService> PoolCleaner<T> cleaner(T pool) {
832	<	return new PoolCleaner<T>(pool);
831	>	/**
832	>	* An extension of PoolCleaner that has an action to release the pool.
833	>	*/
834	>	class PoolCleanerWithReleaser extends PoolCleaner {
835	>	private final Runnable releaser;
836	>	public PoolCleanerWithReleaser(ExecutorService pool, Runnable releaser) {
837	>	super(pool);
838	>	this.releaser = releaser;
839	>	}
840	>	public void close() {
841	>	try {
842	>	releaser.run();
843	>	} finally {
844	>	super.close();
845	>	}
846	>	}
847	>	}
848	>
849	>	PoolCleaner cleaner(ExecutorService pool) {
850	>	return new PoolCleaner(pool);
851	>	}
852	>
853	>	PoolCleaner cleaner(ExecutorService pool, Runnable releaser) {
854	>	return new PoolCleanerWithReleaser(pool, releaser);
855	>	}
856	>
857	>	PoolCleaner cleaner(ExecutorService pool, CountDownLatch latch) {
858	>	return new PoolCleanerWithReleaser(pool, releaser(latch));
859	>	}
860	>
861	>	Runnable releaser(final CountDownLatch latch) {
862	>	return new Runnable() { public void run() {
863	>	do { latch.countDown(); }
864	>	while (latch.getCount() > 0);
865	>	}};
866		}
867
868		/**
#	Line 794 | Line 878 | public class JSR166TestCase extends Test
878		} finally {
879		// last resort, for the benefit of subsequent tests
880		pool.shutdownNow();
881	<	pool.awaitTermination(SMALL_DELAY_MS, MILLISECONDS);
881	>	pool.awaitTermination(MEDIUM_DELAY_MS, MILLISECONDS);
882		}
883		}
884		} catch (SecurityException ok) {
#	Line 813 | Line 897 | public class JSR166TestCase extends Test
897		* necessarily individually slow because they must block.
898		*/
899		void testInParallel(Action ... actions) {
900	<	try (PoolCleaner<ExecutorService> cleaner
901	<	= cleaner(Executors.newCachedThreadPool())) {
818	<	ExecutorService pool = cleaner.pool;
900	>	ExecutorService pool = Executors.newCachedThreadPool();
901	>	try (PoolCleaner cleaner = cleaner(pool)) {
902		ArrayList<Future<?>> futures = new ArrayList<>(actions.length);
903		for (final Action action : actions)
904		futures.add(pool.submit(new CheckedRunnable() {
#	Line 1172 | Line 1255 | public class JSR166TestCase extends Test
1255		} finally {
1256		if (t.getState() != Thread.State.TERMINATED) {
1257		t.interrupt();
1258	<	fail("Test timed out");
1258	>	threadFail("timed out waiting for thread to terminate");
1259		}
1260		}
1261		}
#	Line 1320 | Line 1403 | public class JSR166TestCase extends Test
1403		}};
1404		}
1405
1406	<	public Runnable awaiter(final CountDownLatch latch) {
1407	<	return new CheckedRunnable() {
1408	<	public void realRun() throws InterruptedException {
1409	<	await(latch);
1410	<	}};
1406	>	class LatchAwaiter extends CheckedRunnable {
1407	>	static final int NEW = 0;
1408	>	static final int RUNNING = 1;
1409	>	static final int DONE = 2;
1410	>	final CountDownLatch latch;
1411	>	int state = NEW;
1412	>	LatchAwaiter(CountDownLatch latch) { this.latch = latch; }
1413	>	public void realRun() throws InterruptedException {
1414	>	state = 1;
1415	>	await(latch);
1416	>	state = 2;
1417	>	}
1418	>	}
1419	>
1420	>	public LatchAwaiter awaiter(CountDownLatch latch) {
1421	>	return new LatchAwaiter(latch);
1422		}
1423
1424		public void await(CountDownLatch latch) {
1425		try {
1426	<	assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
1426	>	if (!latch.await(LONG_DELAY_MS, MILLISECONDS))
1427	>	fail("timed out waiting for CountDownLatch for "
1428	>	+ (LONG_DELAY_MS/1000) + " sec");
1429		} catch (Throwable fail) {
1430		threadUnexpectedException(fail);
1431		}
#	Line 1337 | Line 1433 | public class JSR166TestCase extends Test
1433
1434		public void await(Semaphore semaphore) {
1435		try {
1436	<	assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
1436	>	if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1437	>	fail("timed out waiting for Semaphore for "
1438	>	+ (LONG_DELAY_MS/1000) + " sec");
1439		} catch (Throwable fail) {
1440		threadUnexpectedException(fail);
1441		}

Diff Legend

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