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.55 by jsr166, Mon Sep 20 20:42:37 2010 UTC vs.
Revision 1.60 by jsr166, Wed Oct 6 07:49:22 2010 UTC

#	Line 105 | Line 105 | public class JSR166TestCase extends Test
105		Policy.setPolicy(permissivePolicy());
106		System.setSecurityManager(new SecurityManager());
107		}
108	<	int iters = 1;
109	<	if (args.length > 0)
110	<	iters = Integer.parseInt(args[0]);
108	>	int iters = (args.length == 0) ? 1 : Integer.parseInt(args[0]);
109	>
110		Test s = suite();
111		for (int i = 0; i < iters; ++i) {
112		junit.textui.TestRunner.run(s);
#	Line 117 | Line 116 | public class JSR166TestCase extends Test
116		System.exit(0);
117		}
118
119	+	public static TestSuite newTestSuite(Object... suiteOrClasses) {
120	+	TestSuite suite = new TestSuite();
121	+	for (Object suiteOrClass : suiteOrClasses) {
122	+	if (suiteOrClass instanceof TestSuite)
123	+	suite.addTest((TestSuite) suiteOrClass);
124	+	else if (suiteOrClass instanceof Class)
125	+	suite.addTest(new TestSuite((Class<?>) suiteOrClass));
126	+	else
127	+	throw new ClassCastException("not a test suite or class");
128	+	}
129	+	return suite;
130	+	}
131	+
132		/**
133	<	* Collects all JSR166 unit tests as one suite
133	>	* Collects all JSR166 unit tests as one suite.
134		*/
135		public static Test suite() {
136	<	TestSuite suite = new TestSuite("JSR166 Unit Tests");
137	<
138	<	suite.addTest(new TestSuite(ForkJoinPoolTest.class));
139	<	suite.addTest(new TestSuite(ForkJoinTaskTest.class));
140	<	suite.addTest(new TestSuite(RecursiveActionTest.class));
141	<	suite.addTest(new TestSuite(RecursiveTaskTest.class));
142	<	suite.addTest(new TestSuite(LinkedTransferQueueTest.class));
143	<	suite.addTest(new TestSuite(PhaserTest.class));
144	<	suite.addTest(new TestSuite(ThreadLocalRandomTest.class));
145	<	suite.addTest(new TestSuite(AbstractExecutorServiceTest.class));
146	<	suite.addTest(new TestSuite(AbstractQueueTest.class));
147	<	suite.addTest(new TestSuite(AbstractQueuedSynchronizerTest.class));
148	<	suite.addTest(new TestSuite(AbstractQueuedLongSynchronizerTest.class));
149	<	suite.addTest(new TestSuite(ArrayBlockingQueueTest.class));
150	<	suite.addTest(new TestSuite(ArrayDequeTest.class));
151	<	suite.addTest(new TestSuite(AtomicBooleanTest.class));
152	<	suite.addTest(new TestSuite(AtomicIntegerArrayTest.class));
153	<	suite.addTest(new TestSuite(AtomicIntegerFieldUpdaterTest.class));
154	<	suite.addTest(new TestSuite(AtomicIntegerTest.class));
155	<	suite.addTest(new TestSuite(AtomicLongArrayTest.class));
156	<	suite.addTest(new TestSuite(AtomicLongFieldUpdaterTest.class));
157	<	suite.addTest(new TestSuite(AtomicLongTest.class));
158	<	suite.addTest(new TestSuite(AtomicMarkableReferenceTest.class));
159	<	suite.addTest(new TestSuite(AtomicReferenceArrayTest.class));
160	<	suite.addTest(new TestSuite(AtomicReferenceFieldUpdaterTest.class));
161	<	suite.addTest(new TestSuite(AtomicReferenceTest.class));
162	<	suite.addTest(new TestSuite(AtomicStampedReferenceTest.class));
163	<	suite.addTest(new TestSuite(ConcurrentHashMapTest.class));
164	<	suite.addTest(new TestSuite(ConcurrentLinkedDequeTest.class));
165	<	suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.class));
166	<	suite.addTest(new TestSuite(ConcurrentSkipListMapTest.class));
167	<	suite.addTest(new TestSuite(ConcurrentSkipListSubMapTest.class));
168	<	suite.addTest(new TestSuite(ConcurrentSkipListSetTest.class));
169	<	suite.addTest(new TestSuite(ConcurrentSkipListSubSetTest.class));
170	<	suite.addTest(new TestSuite(CopyOnWriteArrayListTest.class));
171	<	suite.addTest(new TestSuite(CopyOnWriteArraySetTest.class));
172	<	suite.addTest(new TestSuite(CountDownLatchTest.class));
173	<	suite.addTest(new TestSuite(CyclicBarrierTest.class));
174	<	suite.addTest(new TestSuite(DelayQueueTest.class));
175	<	suite.addTest(new TestSuite(EntryTest.class));
176	<	suite.addTest(new TestSuite(ExchangerTest.class));
177	<	suite.addTest(new TestSuite(ExecutorsTest.class));
178	<	suite.addTest(new TestSuite(ExecutorCompletionServiceTest.class));
179	<	suite.addTest(new TestSuite(FutureTaskTest.class));
180	<	suite.addTest(new TestSuite(LinkedBlockingDequeTest.class));
181	<	suite.addTest(new TestSuite(LinkedBlockingQueueTest.class));
182	<	suite.addTest(new TestSuite(LinkedListTest.class));
183	<	suite.addTest(new TestSuite(LockSupportTest.class));
184	<	suite.addTest(new TestSuite(PriorityBlockingQueueTest.class));
185	<	suite.addTest(new TestSuite(PriorityQueueTest.class));
186	<	suite.addTest(new TestSuite(ReentrantLockTest.class));
187	<	suite.addTest(new TestSuite(ReentrantReadWriteLockTest.class));
188	<	suite.addTest(new TestSuite(ScheduledExecutorTest.class));
189	<	suite.addTest(new TestSuite(ScheduledExecutorSubclassTest.class));
190	<	suite.addTest(new TestSuite(SemaphoreTest.class));
191	<	suite.addTest(new TestSuite(SynchronousQueueTest.class));
192	<	suite.addTest(new TestSuite(SystemTest.class));
193	<	suite.addTest(new TestSuite(ThreadLocalTest.class));
194	<	suite.addTest(new TestSuite(ThreadPoolExecutorTest.class));
195	<	suite.addTest(new TestSuite(ThreadPoolExecutorSubclassTest.class));
196	<	suite.addTest(new TestSuite(ThreadTest.class));
197	<	suite.addTest(new TestSuite(TimeUnitTest.class));
198	<	suite.addTest(new TestSuite(TreeMapTest.class));
199	<	suite.addTest(new TestSuite(TreeSetTest.class));
200	<	suite.addTest(new TestSuite(TreeSubMapTest.class));
189	<	suite.addTest(new TestSuite(TreeSubSetTest.class));
190	<
191	<	return suite;
136	>	return newTestSuite(
137	>	ForkJoinPoolTest.suite(),
138	>	ForkJoinTaskTest.suite(),
139	>	RecursiveActionTest.suite(),
140	>	RecursiveTaskTest.suite(),
141	>	LinkedTransferQueueTest.suite(),
142	>	PhaserTest.suite(),
143	>	ThreadLocalRandomTest.suite(),
144	>	AbstractExecutorServiceTest.suite(),
145	>	AbstractQueueTest.suite(),
146	>	AbstractQueuedSynchronizerTest.suite(),
147	>	AbstractQueuedLongSynchronizerTest.suite(),
148	>	ArrayBlockingQueueTest.suite(),
149	>	ArrayDequeTest.suite(),
150	>	AtomicBooleanTest.suite(),
151	>	AtomicIntegerArrayTest.suite(),
152	>	AtomicIntegerFieldUpdaterTest.suite(),
153	>	AtomicIntegerTest.suite(),
154	>	AtomicLongArrayTest.suite(),
155	>	AtomicLongFieldUpdaterTest.suite(),
156	>	AtomicLongTest.suite(),
157	>	AtomicMarkableReferenceTest.suite(),
158	>	AtomicReferenceArrayTest.suite(),
159	>	AtomicReferenceFieldUpdaterTest.suite(),
160	>	AtomicReferenceTest.suite(),
161	>	AtomicStampedReferenceTest.suite(),
162	>	ConcurrentHashMapTest.suite(),
163	>	ConcurrentLinkedDequeTest.suite(),
164	>	ConcurrentLinkedQueueTest.suite(),
165	>	ConcurrentSkipListMapTest.suite(),
166	>	ConcurrentSkipListSubMapTest.suite(),
167	>	ConcurrentSkipListSetTest.suite(),
168	>	ConcurrentSkipListSubSetTest.suite(),
169	>	CopyOnWriteArrayListTest.suite(),
170	>	CopyOnWriteArraySetTest.suite(),
171	>	CountDownLatchTest.suite(),
172	>	CyclicBarrierTest.suite(),
173	>	DelayQueueTest.suite(),
174	>	EntryTest.suite(),
175	>	ExchangerTest.suite(),
176	>	ExecutorsTest.suite(),
177	>	ExecutorCompletionServiceTest.suite(),
178	>	FutureTaskTest.suite(),
179	>	LinkedBlockingDequeTest.suite(),
180	>	LinkedBlockingQueueTest.suite(),
181	>	LinkedListTest.suite(),
182	>	LockSupportTest.suite(),
183	>	PriorityBlockingQueueTest.suite(),
184	>	PriorityQueueTest.suite(),
185	>	ReentrantLockTest.suite(),
186	>	ReentrantReadWriteLockTest.suite(),
187	>	ScheduledExecutorTest.suite(),
188	>	ScheduledExecutorSubclassTest.suite(),
189	>	SemaphoreTest.suite(),
190	>	SynchronousQueueTest.suite(),
191	>	SystemTest.suite(),
192	>	ThreadLocalTest.suite(),
193	>	ThreadPoolExecutorTest.suite(),
194	>	ThreadPoolExecutorSubclassTest.suite(),
195	>	ThreadTest.suite(),
196	>	TimeUnitTest.suite(),
197	>	TreeMapTest.suite(),
198	>	TreeSetTest.suite(),
199	>	TreeSubMapTest.suite(),
200	>	TreeSubSetTest.suite());
201		}
202
203
#	Line 251 | Line 260 | public class JSR166TestCase extends Test
260		throw (RuntimeException) t;
261		else if (t instanceof Exception)
262		throw (Exception) t;
263	<	else
264	<	throw new AssertionError(t);
263	>	else {
264	>	AssertionFailedError afe =
265	>	new AssertionFailedError(t.toString());
266	>	afe.initCause(t);
267	>	throw afe;
268	>	}
269		}
270		}
271
272		/**
273		* Just like fail(reason), but additionally recording (using
274	<	* threadRecordFailure) any AssertionError thrown, so that the current
275	<	* testcase will fail.
274	>	* threadRecordFailure) any AssertionFailedError thrown, so that
275	>	* the current testcase will fail.
276		*/
277		public void threadFail(String reason) {
278		try {
279		fail(reason);
280	<	} catch (Throwable t) {
280	>	} catch (AssertionFailedError t) {
281		threadRecordFailure(t);
282		fail(reason);
283		}
#	Line 272 | Line 285 | public class JSR166TestCase extends Test
285
286		/**
287		* Just like assertTrue(b), but additionally recording (using
288	<	* threadRecordFailure) any AssertionError thrown, so that the current
289	<	* testcase will fail.
288	>	* threadRecordFailure) any AssertionFailedError thrown, so that
289	>	* the current testcase will fail.
290		*/
291		public void threadAssertTrue(boolean b) {
292		try {
293		assertTrue(b);
294	<	} catch (AssertionError t) {
294	>	} catch (AssertionFailedError t) {
295		threadRecordFailure(t);
296		throw t;
297		}
#	Line 286 | Line 299 | public class JSR166TestCase extends Test
299
300		/**
301		* Just like assertFalse(b), but additionally recording (using
302	<	* threadRecordFailure) any AssertionError thrown, so that the
303	<	* current testcase will fail.
302	>	* threadRecordFailure) any AssertionFailedError thrown, so that
303	>	* the current testcase will fail.
304		*/
305		public void threadAssertFalse(boolean b) {
306		try {
307		assertFalse(b);
308	<	} catch (AssertionError t) {
308	>	} catch (AssertionFailedError t) {
309		threadRecordFailure(t);
310		throw t;
311		}
#	Line 300 | Line 313 | public class JSR166TestCase extends Test
313
314		/**
315		* Just like assertNull(x), but additionally recording (using
316	<	* threadRecordFailure) any AssertionError thrown, so that the
317	<	* current testcase will fail.
316	>	* threadRecordFailure) any AssertionFailedError thrown, so that
317	>	* the current testcase will fail.
318		*/
319		public void threadAssertNull(Object x) {
320		try {
321		assertNull(x);
322	<	} catch (AssertionError t) {
322	>	} catch (AssertionFailedError t) {
323		threadRecordFailure(t);
324		throw t;
325		}
#	Line 314 | Line 327 | public class JSR166TestCase extends Test
327
328		/**
329		* Just like assertEquals(x, y), but additionally recording (using
330	<	* threadRecordFailure) any AssertionError thrown, so that the
331	<	* current testcase will fail.
330	>	* threadRecordFailure) any AssertionFailedError thrown, so that
331	>	* the current testcase will fail.
332		*/
333		public void threadAssertEquals(long x, long y) {
334		try {
335		assertEquals(x, y);
336	<	} catch (AssertionError t) {
336	>	} catch (AssertionFailedError t) {
337		threadRecordFailure(t);
338		throw t;
339		}
#	Line 328 | Line 341 | public class JSR166TestCase extends Test
341
342		/**
343		* Just like assertEquals(x, y), but additionally recording (using
344	<	* threadRecordFailure) any AssertionError thrown, so that the
345	<	* current testcase will fail.
344	>	* threadRecordFailure) any AssertionFailedError thrown, so that
345	>	* the current testcase will fail.
346		*/
347		public void threadAssertEquals(Object x, Object y) {
348		try {
349		assertEquals(x, y);
350	<	} catch (AssertionError t) {
350	>	} catch (AssertionFailedError t) {
351		threadRecordFailure(t);
352		throw t;
353	+	} catch (Throwable t) {
354	+	threadUnexpectedException(t);
355		}
356		}
357
358		/**
359		* Just like assertSame(x, y), but additionally recording (using
360	<	* threadRecordFailure) any AssertionError thrown, so that the
361	<	* current testcase will fail.
360	>	* threadRecordFailure) any AssertionFailedError thrown, so that
361	>	* the current testcase will fail.
362		*/
363		public void threadAssertSame(Object x, Object y) {
364		try {
365		assertSame(x, y);
366	<	} catch (AssertionError t) {
366	>	} catch (AssertionFailedError t) {
367		threadRecordFailure(t);
368		throw t;
369		}
#	Line 369 | Line 384 | public class JSR166TestCase extends Test
384		}
385
386		/**
387	<	* Calls threadFail with message "Unexpected exception" + ex.
387	>	* Records the given exception using {@link #threadRecordFailure},
388	>	* then rethrows the exception, wrapping it in an
389	>	* AssertionFailedError if necessary.
390		*/
391		public void threadUnexpectedException(Throwable t) {
392		threadRecordFailure(t);
393		t.printStackTrace();
377	–	// Rethrow, wrapping in an AssertionError if necessary
394		if (t instanceof RuntimeException)
395		throw (RuntimeException) t;
396		else if (t instanceof Error)
397		throw (Error) t;
398		else {
399	<	AssertionError ae = new AssertionError("unexpected exception: " + t);
399	>	AssertionFailedError afe =
400	>	new AssertionFailedError("unexpected exception: " + t);
401		t.initCause(t);
402	<	throw ae;
402	>	throw afe;
403		}
404		}
405
#	Line 417 | Line 434 | public class JSR166TestCase extends Test
434		}
435
436		/**
420	–	* Fails with message "Unexpected exception: " + ex.
421	–	*/
422	–	public void unexpectedException(Throwable ex) {
423	–	ex.printStackTrace();
424	–	fail("Unexpected exception: " + ex);
425	–	}
426	–
427	–
428	–	/**
437		* The number of elements to place in collections, arrays, etc.
438		*/
439		public static final int SIZE = 20;
#	Line 536 | Line 544 | public class JSR166TestCase extends Test
544		}
545
546		/**
547	<	* Sleep until the timeout has elapsed, or interrupted.
547	>	* Sleeps until the given time has elapsed.
548	>	* Throws AssertionFailedError if interrupted.
549	>	*/
550	>	void sleep(long millis) {
551	>	try {
552	>	Thread.sleep(millis);
553	>	} catch (InterruptedException ie) {
554	>	AssertionFailedError afe =
555	>	new AssertionFailedError("Unexpected InterruptedException");
556	>	afe.initCause(ie);
557	>	throw afe;
558	>	}
559	>	}
560	>
561	>	/**
562	>	* Sleeps until the timeout has elapsed, or interrupted.
563		* Does <em>NOT</em> throw InterruptedException.
564		*/
565		void sleepTillInterrupted(long timeoutMillis) {
#	Line 546 | Line 569 | public class JSR166TestCase extends Test
569		}
570
571		/**
572	<	* Returns a new started Thread running the given runnable.
572	>	* Returns a new started daemon Thread running the given runnable.
573		*/
574		Thread newStartedThread(Runnable runnable) {
575		Thread t = new Thread(runnable);
576	+	t.setDaemon(true);
577		t.start();
578		return t;
579		}
580
581	+	/**
582	+	* Waits for the specified time (in milliseconds) for the thread
583	+	* to terminate (using {@link Thread#join(long)}), else interrupts
584	+	* the thread (in the hope that it may terminate later) and fails.
585	+	*/
586	+	void awaitTermination(Thread t, long timeoutMillis) {
587	+	try {
588	+	t.join(timeoutMillis);
589	+	} catch (InterruptedException ie) {
590	+	threadUnexpectedException(ie);
591	+	} finally {
592	+	if (t.isAlive()) {
593	+	t.interrupt();
594	+	fail("Test timed out");
595	+	}
596	+	}
597	+	}
598	+
599		// Some convenient Runnable classes
600
601		public abstract class CheckedRunnable implements Runnable {
#	Line 717 | Line 759 | public class JSR166TestCase extends Test
759		}
760		}
761
720	–	public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
721	–	protected void realRun() throws InterruptedException {
722	–	Thread.sleep(SMALL_DELAY_MS);
723	–	}
724	–	}
725	–
762		public class MediumRunnable extends CheckedRunnable {
763		protected void realRun() throws Throwable {
764		Thread.sleep(MEDIUM_DELAY_MS);
#	Line 847 | Line 883 | public class JSR166TestCase extends Test
883		ThreadPoolExecutor executor) {}
884		}
885
886	+	/**
887	+	* A CyclicBarrier that fails with AssertionFailedErrors instead
888	+	* of throwing checked exceptions.
889	+	*/
890	+	public class CheckedBarrier extends CyclicBarrier {
891	+	public CheckedBarrier(int parties) { super(parties); }
892	+
893	+	public int await() {
894	+	try {
895	+	return super.await();
896	+	} catch (Exception e) {
897	+	AssertionFailedError afe =
898	+	new AssertionFailedError("Unexpected exception: " + e);
899	+	afe.initCause(e);
900	+	throw afe;
901	+	}
902	+	}
903	+	}
904	+
905		}

Diff Legend

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