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.53 by jsr166, Thu Sep 16 00:52:49 2010 UTC vs.
Revision 1.63 by jsr166, Mon Oct 11 08:30:01 2010 UTC

#	Line 96 | Line 96 | public class JSR166TestCase extends Test
96		private static final boolean useSecurityManager =
97		Boolean.getBoolean("jsr166.useSecurityManager");
98
99	+	protected static final boolean expensiveTests =
100	+	Boolean.getBoolean("jsr166.expensiveTests");
101	+
102	+	/**
103	+	* If true, report on stdout all "slow" tests, that is, ones that
104	+	* take more than profileThreshold milliseconds to execute.
105	+	*/
106	+	private static final boolean profileTests =
107	+	Boolean.getBoolean("jsr166.profileTests");
108	+
109	+	/**
110	+	* The number of milliseconds that tests are permitted for
111	+	* execution without being reported, when profileTests is set.
112	+	*/
113	+	private static final long profileThreshold =
114	+	Long.getLong("jsr166.profileThreshold", 100);
115	+
116	+	protected void runTest() throws Throwable {
117	+	if (profileTests)
118	+	runTestProfiled();
119	+	else
120	+	super.runTest();
121	+	}
122	+
123	+	protected void runTestProfiled() throws Throwable {
124	+	long t0 = System.nanoTime();
125	+	try {
126	+	super.runTest();
127	+	} finally {
128	+	long elapsedMillis =
129	+	(System.nanoTime() - t0) / (1000L * 1000L);
130	+	if (elapsedMillis >= profileThreshold)
131	+	System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
132	+	}
133	+	}
134	+
135		/**
136		* Runs all JSR166 unit tests using junit.textui.TestRunner
137		*/
#	Line 105 | Line 141 | public class JSR166TestCase extends Test
141		Policy.setPolicy(permissivePolicy());
142		System.setSecurityManager(new SecurityManager());
143		}
144	<	int iters = 1;
145	<	if (args.length > 0)
110	<	iters = Integer.parseInt(args[0]);
144	>	int iters = (args.length == 0) ? 1 : Integer.parseInt(args[0]);
145	>
146		Test s = suite();
147		for (int i = 0; i < iters; ++i) {
148		junit.textui.TestRunner.run(s);
#	Line 117 | Line 152 | public class JSR166TestCase extends Test
152		System.exit(0);
153		}
154
155	+	public static TestSuite newTestSuite(Object... suiteOrClasses) {
156	+	TestSuite suite = new TestSuite();
157	+	for (Object suiteOrClass : suiteOrClasses) {
158	+	if (suiteOrClass instanceof TestSuite)
159	+	suite.addTest((TestSuite) suiteOrClass);
160	+	else if (suiteOrClass instanceof Class)
161	+	suite.addTest(new TestSuite((Class<?>) suiteOrClass));
162	+	else
163	+	throw new ClassCastException("not a test suite or class");
164	+	}
165	+	return suite;
166	+	}
167	+
168		/**
169	<	* Collects all JSR166 unit tests as one suite
169	>	* Collects all JSR166 unit tests as one suite.
170		*/
171		public static Test suite() {
172	<	TestSuite suite = new TestSuite("JSR166 Unit Tests");
173	<
174	<	suite.addTest(new TestSuite(ForkJoinPoolTest.class));
175	<	suite.addTest(new TestSuite(ForkJoinTaskTest.class));
176	<	suite.addTest(new TestSuite(RecursiveActionTest.class));
177	<	suite.addTest(new TestSuite(RecursiveTaskTest.class));
178	<	suite.addTest(new TestSuite(LinkedTransferQueueTest.class));
179	<	suite.addTest(new TestSuite(PhaserTest.class));
180	<	suite.addTest(new TestSuite(ThreadLocalRandomTest.class));
181	<	suite.addTest(new TestSuite(AbstractExecutorServiceTest.class));
182	<	suite.addTest(new TestSuite(AbstractQueueTest.class));
183	<	suite.addTest(new TestSuite(AbstractQueuedSynchronizerTest.class));
184	<	suite.addTest(new TestSuite(AbstractQueuedLongSynchronizerTest.class));
185	<	suite.addTest(new TestSuite(ArrayBlockingQueueTest.class));
186	<	suite.addTest(new TestSuite(ArrayDequeTest.class));
187	<	suite.addTest(new TestSuite(AtomicBooleanTest.class));
188	<	suite.addTest(new TestSuite(AtomicIntegerArrayTest.class));
189	<	suite.addTest(new TestSuite(AtomicIntegerFieldUpdaterTest.class));
190	<	suite.addTest(new TestSuite(AtomicIntegerTest.class));
191	<	suite.addTest(new TestSuite(AtomicLongArrayTest.class));
192	<	suite.addTest(new TestSuite(AtomicLongFieldUpdaterTest.class));
193	<	suite.addTest(new TestSuite(AtomicLongTest.class));
194	<	suite.addTest(new TestSuite(AtomicMarkableReferenceTest.class));
195	<	suite.addTest(new TestSuite(AtomicReferenceArrayTest.class));
196	<	suite.addTest(new TestSuite(AtomicReferenceFieldUpdaterTest.class));
197	<	suite.addTest(new TestSuite(AtomicReferenceTest.class));
198	<	suite.addTest(new TestSuite(AtomicStampedReferenceTest.class));
199	<	suite.addTest(new TestSuite(ConcurrentHashMapTest.class));
200	<	suite.addTest(new TestSuite(ConcurrentLinkedDequeTest.class));
201	<	suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.class));
202	<	suite.addTest(new TestSuite(ConcurrentSkipListMapTest.class));
203	<	suite.addTest(new TestSuite(ConcurrentSkipListSubMapTest.class));
204	<	suite.addTest(new TestSuite(ConcurrentSkipListSetTest.class));
205	<	suite.addTest(new TestSuite(ConcurrentSkipListSubSetTest.class));
206	<	suite.addTest(new TestSuite(CopyOnWriteArrayListTest.class));
207	<	suite.addTest(new TestSuite(CopyOnWriteArraySetTest.class));
208	<	suite.addTest(new TestSuite(CountDownLatchTest.class));
209	<	suite.addTest(new TestSuite(CyclicBarrierTest.class));
210	<	suite.addTest(new TestSuite(DelayQueueTest.class));
211	<	suite.addTest(new TestSuite(EntryTest.class));
212	<	suite.addTest(new TestSuite(ExchangerTest.class));
213	<	suite.addTest(new TestSuite(ExecutorsTest.class));
214	<	suite.addTest(new TestSuite(ExecutorCompletionServiceTest.class));
215	<	suite.addTest(new TestSuite(FutureTaskTest.class));
216	<	suite.addTest(new TestSuite(LinkedBlockingDequeTest.class));
217	<	suite.addTest(new TestSuite(LinkedBlockingQueueTest.class));
218	<	suite.addTest(new TestSuite(LinkedListTest.class));
219	<	suite.addTest(new TestSuite(LockSupportTest.class));
220	<	suite.addTest(new TestSuite(PriorityBlockingQueueTest.class));
221	<	suite.addTest(new TestSuite(PriorityQueueTest.class));
222	<	suite.addTest(new TestSuite(ReentrantLockTest.class));
223	<	suite.addTest(new TestSuite(ReentrantReadWriteLockTest.class));
224	<	suite.addTest(new TestSuite(ScheduledExecutorTest.class));
225	<	suite.addTest(new TestSuite(ScheduledExecutorSubclassTest.class));
226	<	suite.addTest(new TestSuite(SemaphoreTest.class));
227	<	suite.addTest(new TestSuite(SynchronousQueueTest.class));
228	<	suite.addTest(new TestSuite(SystemTest.class));
229	<	suite.addTest(new TestSuite(ThreadLocalTest.class));
230	<	suite.addTest(new TestSuite(ThreadPoolExecutorTest.class));
231	<	suite.addTest(new TestSuite(ThreadPoolExecutorSubclassTest.class));
232	<	suite.addTest(new TestSuite(ThreadTest.class));
233	<	suite.addTest(new TestSuite(TimeUnitTest.class));
234	<	suite.addTest(new TestSuite(TreeMapTest.class));
235	<	suite.addTest(new TestSuite(TreeSetTest.class));
236	<	suite.addTest(new TestSuite(TreeSubMapTest.class));
189	<	suite.addTest(new TestSuite(TreeSubSetTest.class));
190	<
191	<	return suite;
172	>	return newTestSuite(
173	>	ForkJoinPoolTest.suite(),
174	>	ForkJoinTaskTest.suite(),
175	>	RecursiveActionTest.suite(),
176	>	RecursiveTaskTest.suite(),
177	>	LinkedTransferQueueTest.suite(),
178	>	PhaserTest.suite(),
179	>	ThreadLocalRandomTest.suite(),
180	>	AbstractExecutorServiceTest.suite(),
181	>	AbstractQueueTest.suite(),
182	>	AbstractQueuedSynchronizerTest.suite(),
183	>	AbstractQueuedLongSynchronizerTest.suite(),
184	>	ArrayBlockingQueueTest.suite(),
185	>	ArrayDequeTest.suite(),
186	>	AtomicBooleanTest.suite(),
187	>	AtomicIntegerArrayTest.suite(),
188	>	AtomicIntegerFieldUpdaterTest.suite(),
189	>	AtomicIntegerTest.suite(),
190	>	AtomicLongArrayTest.suite(),
191	>	AtomicLongFieldUpdaterTest.suite(),
192	>	AtomicLongTest.suite(),
193	>	AtomicMarkableReferenceTest.suite(),
194	>	AtomicReferenceArrayTest.suite(),
195	>	AtomicReferenceFieldUpdaterTest.suite(),
196	>	AtomicReferenceTest.suite(),
197	>	AtomicStampedReferenceTest.suite(),
198	>	ConcurrentHashMapTest.suite(),
199	>	ConcurrentLinkedDequeTest.suite(),
200	>	ConcurrentLinkedQueueTest.suite(),
201	>	ConcurrentSkipListMapTest.suite(),
202	>	ConcurrentSkipListSubMapTest.suite(),
203	>	ConcurrentSkipListSetTest.suite(),
204	>	ConcurrentSkipListSubSetTest.suite(),
205	>	CopyOnWriteArrayListTest.suite(),
206	>	CopyOnWriteArraySetTest.suite(),
207	>	CountDownLatchTest.suite(),
208	>	CyclicBarrierTest.suite(),
209	>	DelayQueueTest.suite(),
210	>	EntryTest.suite(),
211	>	ExchangerTest.suite(),
212	>	ExecutorsTest.suite(),
213	>	ExecutorCompletionServiceTest.suite(),
214	>	FutureTaskTest.suite(),
215	>	LinkedBlockingDequeTest.suite(),
216	>	LinkedBlockingQueueTest.suite(),
217	>	LinkedListTest.suite(),
218	>	LockSupportTest.suite(),
219	>	PriorityBlockingQueueTest.suite(),
220	>	PriorityQueueTest.suite(),
221	>	ReentrantLockTest.suite(),
222	>	ReentrantReadWriteLockTest.suite(),
223	>	ScheduledExecutorTest.suite(),
224	>	ScheduledExecutorSubclassTest.suite(),
225	>	SemaphoreTest.suite(),
226	>	SynchronousQueueTest.suite(),
227	>	SystemTest.suite(),
228	>	ThreadLocalTest.suite(),
229	>	ThreadPoolExecutorTest.suite(),
230	>	ThreadPoolExecutorSubclassTest.suite(),
231	>	ThreadTest.suite(),
232	>	TimeUnitTest.suite(),
233	>	TreeMapTest.suite(),
234	>	TreeSetTest.suite(),
235	>	TreeSubMapTest.suite(),
236	>	TreeSubSetTest.suite());
237		}
238
239
#	Line 251 | Line 296 | public class JSR166TestCase extends Test
296		throw (RuntimeException) t;
297		else if (t instanceof Exception)
298		throw (Exception) t;
299	<	else
300	<	throw new AssertionError(t);
299	>	else {
300	>	AssertionFailedError afe =
301	>	new AssertionFailedError(t.toString());
302	>	afe.initCause(t);
303	>	throw afe;
304	>	}
305		}
306		}
307
308		/**
309		* Just like fail(reason), but additionally recording (using
310	<	* threadRecordFailure) any AssertionError thrown, so that the current
311	<	* testcase will fail.
310	>	* threadRecordFailure) any AssertionFailedError thrown, so that
311	>	* the current testcase will fail.
312		*/
313		public void threadFail(String reason) {
314		try {
315		fail(reason);
316	<	} catch (Throwable t) {
316	>	} catch (AssertionFailedError t) {
317		threadRecordFailure(t);
318		fail(reason);
319		}
#	Line 272 | Line 321 | public class JSR166TestCase extends Test
321
322		/**
323		* Just like assertTrue(b), but additionally recording (using
324	<	* threadRecordFailure) any AssertionError thrown, so that the current
325	<	* testcase will fail.
324	>	* threadRecordFailure) any AssertionFailedError thrown, so that
325	>	* the current testcase will fail.
326		*/
327		public void threadAssertTrue(boolean b) {
328		try {
329		assertTrue(b);
330	<	} catch (AssertionError t) {
330	>	} catch (AssertionFailedError t) {
331		threadRecordFailure(t);
332		throw t;
333		}
#	Line 286 | Line 335 | public class JSR166TestCase extends Test
335
336		/**
337		* Just like assertFalse(b), but additionally recording (using
338	<	* threadRecordFailure) any AssertionError thrown, so that the
339	<	* current testcase will fail.
338	>	* threadRecordFailure) any AssertionFailedError thrown, so that
339	>	* the current testcase will fail.
340		*/
341		public void threadAssertFalse(boolean b) {
342		try {
343		assertFalse(b);
344	<	} catch (AssertionError t) {
344	>	} catch (AssertionFailedError t) {
345		threadRecordFailure(t);
346		throw t;
347		}
#	Line 300 | Line 349 | public class JSR166TestCase extends Test
349
350		/**
351		* Just like assertNull(x), but additionally recording (using
352	<	* threadRecordFailure) any AssertionError thrown, so that the
353	<	* current testcase will fail.
352	>	* threadRecordFailure) any AssertionFailedError thrown, so that
353	>	* the current testcase will fail.
354		*/
355		public void threadAssertNull(Object x) {
356		try {
357		assertNull(x);
358	<	} catch (AssertionError t) {
358	>	} catch (AssertionFailedError t) {
359		threadRecordFailure(t);
360		throw t;
361		}
#	Line 314 | Line 363 | public class JSR166TestCase extends Test
363
364		/**
365		* Just like assertEquals(x, y), but additionally recording (using
366	<	* threadRecordFailure) any AssertionError thrown, so that the
367	<	* current testcase will fail.
366	>	* threadRecordFailure) any AssertionFailedError thrown, so that
367	>	* the current testcase will fail.
368		*/
369		public void threadAssertEquals(long x, long y) {
370		try {
371		assertEquals(x, y);
372	<	} catch (AssertionError t) {
372	>	} catch (AssertionFailedError t) {
373		threadRecordFailure(t);
374		throw t;
375		}
#	Line 328 | Line 377 | public class JSR166TestCase extends Test
377
378		/**
379		* Just like assertEquals(x, y), but additionally recording (using
380	<	* threadRecordFailure) any AssertionError thrown, so that the
381	<	* current testcase will fail.
380	>	* threadRecordFailure) any AssertionFailedError thrown, so that
381	>	* the current testcase will fail.
382		*/
383		public void threadAssertEquals(Object x, Object y) {
384		try {
385		assertEquals(x, y);
386	<	} catch (AssertionError t) {
386	>	} catch (AssertionFailedError t) {
387		threadRecordFailure(t);
388		throw t;
389	+	} catch (Throwable t) {
390	+	threadUnexpectedException(t);
391		}
392		}
393
394		/**
395		* Just like assertSame(x, y), but additionally recording (using
396	<	* threadRecordFailure) any AssertionError thrown, so that the
397	<	* current testcase will fail.
396	>	* threadRecordFailure) any AssertionFailedError thrown, so that
397	>	* the current testcase will fail.
398		*/
399		public void threadAssertSame(Object x, Object y) {
400		try {
401		assertSame(x, y);
402	<	} catch (AssertionError t) {
402	>	} catch (AssertionFailedError t) {
403		threadRecordFailure(t);
404		throw t;
405		}
#	Line 369 | Line 420 | public class JSR166TestCase extends Test
420		}
421
422		/**
423	<	* Calls threadFail with message "Unexpected exception" + ex.
423	>	* Records the given exception using {@link #threadRecordFailure},
424	>	* then rethrows the exception, wrapping it in an
425	>	* AssertionFailedError if necessary.
426		*/
427		public void threadUnexpectedException(Throwable t) {
428		threadRecordFailure(t);
429		t.printStackTrace();
377	–	// Rethrow, wrapping in an AssertionError if necessary
430		if (t instanceof RuntimeException)
431		throw (RuntimeException) t;
432		else if (t instanceof Error)
433		throw (Error) t;
434		else {
435	<	AssertionError ae = new AssertionError("unexpected exception: " + t);
435	>	AssertionFailedError afe =
436	>	new AssertionFailedError("unexpected exception: " + t);
437		t.initCause(t);
438	<	throw ae;
439	<	}
438	>	throw afe;
439	>	}
440		}
441
442		/**
#	Line 392 | Line 445 | public class JSR166TestCase extends Test
445		public void joinPool(ExecutorService exec) {
446		try {
447		exec.shutdown();
448	<	assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
448	>	assertTrue("ExecutorService did not terminate in a timely manner",
449	>	exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
450		} catch (SecurityException ok) {
451		// Allowed in case test doesn't have privs
452		} catch (InterruptedException ie) {
#	Line 416 | Line 470 | public class JSR166TestCase extends Test
470		}
471
472		/**
419	–	* Fails with message "Unexpected exception: " + ex.
420	–	*/
421	–	public void unexpectedException(Throwable ex) {
422	–	ex.printStackTrace();
423	–	fail("Unexpected exception: " + ex);
424	–	}
425	–
426	–
427	–	/**
473		* The number of elements to place in collections, arrays, etc.
474		*/
475		public static final int SIZE = 20;
#	Line 535 | Line 580 | public class JSR166TestCase extends Test
580		}
581
582		/**
583	<	* Sleep until the timeout has elapsed, or interrupted.
583	>	* Sleeps until the given time has elapsed.
584	>	* Throws AssertionFailedError if interrupted.
585	>	*/
586	>	void sleep(long millis) {
587	>	try {
588	>	Thread.sleep(millis);
589	>	} catch (InterruptedException ie) {
590	>	AssertionFailedError afe =
591	>	new AssertionFailedError("Unexpected InterruptedException");
592	>	afe.initCause(ie);
593	>	throw afe;
594	>	}
595	>	}
596	>
597	>	/**
598	>	* Sleeps until the timeout has elapsed, or interrupted.
599		* Does <em>NOT</em> throw InterruptedException.
600		*/
601		void sleepTillInterrupted(long timeoutMillis) {
#	Line 545 | Line 605 | public class JSR166TestCase extends Test
605		}
606
607		/**
608	<	* Returns a new started Thread running the given runnable.
608	>	* Returns a new started daemon Thread running the given runnable.
609		*/
610		Thread newStartedThread(Runnable runnable) {
611		Thread t = new Thread(runnable);
612	+	t.setDaemon(true);
613		t.start();
614		return t;
615		}
616
617	+	/**
618	+	* Waits for the specified time (in milliseconds) for the thread
619	+	* to terminate (using {@link Thread#join(long)}), else interrupts
620	+	* the thread (in the hope that it may terminate later) and fails.
621	+	*/
622	+	void awaitTermination(Thread t, long timeoutMillis) {
623	+	try {
624	+	t.join(timeoutMillis);
625	+	} catch (InterruptedException ie) {
626	+	threadUnexpectedException(ie);
627	+	} finally {
628	+	if (t.isAlive()) {
629	+	t.interrupt();
630	+	fail("Test timed out");
631	+	}
632	+	}
633	+	}
634	+
635		// Some convenient Runnable classes
636
637		public abstract class CheckedRunnable implements Runnable {
#	Line 716 | Line 795 | public class JSR166TestCase extends Test
795		}
796		}
797
719	–	public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
720	–	protected void realRun() throws InterruptedException {
721	–	Thread.sleep(SMALL_DELAY_MS);
722	–	}
723	–	}
724	–
798		public class MediumRunnable extends CheckedRunnable {
799		protected void realRun() throws Throwable {
800		Thread.sleep(MEDIUM_DELAY_MS);
#	Line 734 | Line 807 | public class JSR166TestCase extends Test
807		}
808		}
809
810	+	public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
811	+	return new CheckedRunnable() {
812	+	protected void realRun() {
813	+	try {
814	+	Thread.sleep(timeoutMillis);
815	+	} catch (InterruptedException ok) {}
816	+	}};
817	+	}
818	+
819		public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
820		protected void realRun() {
821		try {
#	Line 759 | Line 841 | public class JSR166TestCase extends Test
841		}
842		}
843
844	+	public interface TrackedRunnable extends Runnable {
845	+	boolean isDone();
846	+	}
847	+
848	+	public static TrackedRunnable trackedRunnable(final long timeoutMillis) {
849	+	return new TrackedRunnable() {
850	+	private volatile boolean done = false;
851	+	public boolean isDone() { return done; }
852	+	public void run() {
853	+	try {
854	+	Thread.sleep(timeoutMillis);
855	+	done = true;
856	+	} catch (InterruptedException ok) {}
857	+	}
858	+	};
859	+	}
860	+
861		public static class TrackedShortRunnable implements Runnable {
862		public volatile boolean done = false;
863		public void run() {
864		try {
865	+	Thread.sleep(SHORT_DELAY_MS);
866	+	done = true;
867	+	} catch (InterruptedException ok) {}
868	+	}
869	+	}
870	+
871	+	public static class TrackedSmallRunnable implements Runnable {
872	+	public volatile boolean done = false;
873	+	public void run() {
874	+	try {
875		Thread.sleep(SMALL_DELAY_MS);
876		done = true;
877		} catch (InterruptedException ok) {}
#	Line 846 | Line 955 | public class JSR166TestCase extends Test
955		ThreadPoolExecutor executor) {}
956		}
957
958	+	/**
959	+	* A CyclicBarrier that fails with AssertionFailedErrors instead
960	+	* of throwing checked exceptions.
961	+	*/
962	+	public class CheckedBarrier extends CyclicBarrier {
963	+	public CheckedBarrier(int parties) { super(parties); }
964	+
965	+	public int await() {
966	+	try {
967	+	return super.await();
968	+	} catch (Exception e) {
969	+	AssertionFailedError afe =
970	+	new AssertionFailedError("Unexpected exception: " + e);
971	+	afe.initCause(e);
972	+	throw afe;
973	+	}
974	+	}
975	+	}
976	+
977		}

Diff Legend

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