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.72 by jsr166, Sun Nov 28 08:43:53 2010 UTC vs.
Revision 1.93 by jsr166, Sun Dec 16 17:22:42 2012 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
10	+	import java.io.ByteArrayInputStream;
11	+	import java.io.ByteArrayOutputStream;
12	+	import java.io.ObjectInputStream;
13	+	import java.io.ObjectOutputStream;
14	+	import java.util.ArrayList;
15		import java.util.Arrays;
16	+	import java.util.Date;
17	+	import java.util.Enumeration;
18	+	import java.util.List;
19		import java.util.NoSuchElementException;
20		import java.util.PropertyPermission;
21		import java.util.concurrent.*;
22	+	import java.util.concurrent.atomic.AtomicBoolean;
23		import java.util.concurrent.atomic.AtomicReference;
24		import static java.util.concurrent.TimeUnit.MILLISECONDS;
25		import static java.util.concurrent.TimeUnit.NANOSECONDS;
#	Line 63 | Line 72 | import java.security.SecurityPermission;
72		*
73		* </ol>
74		*
75	<	* <p> <b>Other notes</b>
75	>	* <p><b>Other notes</b>
76		* <ul>
77		*
78		* <li> Usually, there is one testcase method per JSR166 method
#	Line 254 | Line 263 | public class JSR166TestCase extends Test
263		return 50;
264		}
265
257	–
266		/**
267		* Sets delays as multiples of SHORT_DELAY.
268		*/
#	Line 266 | Line 274 | public class JSR166TestCase extends Test
274		}
275
276		/**
277	+	* Returns a timeout in milliseconds to be used in tests that
278	+	* verify that operations block or time out.
279	+	*/
280	+	long timeoutMillis() {
281	+	return SHORT_DELAY_MS / 4;
282	+	}
283	+
284	+	/**
285	+	* Returns a new Date instance representing a time delayMillis
286	+	* milliseconds in the future.
287	+	*/
288	+	Date delayedDate(long delayMillis) {
289	+	return new Date(System.currentTimeMillis() + delayMillis);
290	+	}
291	+
292	+	/**
293		* The first exception encountered if any threadAssertXXX method fails.
294		*/
295		private final AtomicReference<Throwable> threadFailure
#	Line 286 | Line 310 | public class JSR166TestCase extends Test
310		}
311
312		/**
313	+	* Extra checks that get done for all test cases.
314	+	*
315		* Triggers test case failure if any thread assertions have failed,
316		* by rethrowing, in the test harness thread, any exception recorded
317		* earlier by threadRecordFailure.
318	+	*
319	+	* Triggers test case failure if interrupt status is set in the main thread.
320		*/
321		public void tearDown() throws Exception {
322		Throwable t = threadFailure.getAndSet(null);
#	Line 306 | Line 334 | public class JSR166TestCase extends Test
334		throw afe;
335		}
336		}
337	+
338	+	if (Thread.interrupted())
339	+	throw new AssertionFailedError("interrupt status set in main thread");
340		}
341
342		/**
#	Line 437 | Line 468 | public class JSR166TestCase extends Test
468		else {
469		AssertionFailedError afe =
470		new AssertionFailedError("unexpected exception: " + t);
471	<	t.initCause(t);
471	>	afe.initCause(t);
472		throw afe;
473		}
474		}
475
476		/**
477	+	* Delays, via Thread.sleep, for the given millisecond delay, but
478	+	* if the sleep is shorter than specified, may re-sleep or yield
479	+	* until time elapses.
480	+	*/
481	+	static void delay(long millis) throws InterruptedException {
482	+	long startTime = System.nanoTime();
483	+	long ns = millis * 1000 * 1000;
484	+	for (;;) {
485	+	if (millis > 0L)
486	+	Thread.sleep(millis);
487	+	else // too short to sleep
488	+	Thread.yield();
489	+	long d = ns - (System.nanoTime() - startTime);
490	+	if (d > 0L)
491	+	millis = d / (1000 * 1000);
492	+	else
493	+	break;
494	+	}
495	+	}
496	+
497	+	/**
498		* Waits out termination of a thread pool or fails doing so.
499		*/
500	<	public void joinPool(ExecutorService exec) {
500	>	void joinPool(ExecutorService exec) {
501		try {
502		exec.shutdown();
503		assertTrue("ExecutorService did not terminate in a timely manner",
#	Line 457 | Line 509 | public class JSR166TestCase extends Test
509		}
510		}
511
512	+	/**
513	+	* Checks that thread does not terminate within the default
514	+	* millisecond delay of {@code timeoutMillis()}.
515	+	*/
516	+	void assertThreadStaysAlive(Thread thread) {
517	+	assertThreadStaysAlive(thread, timeoutMillis());
518	+	}
519	+
520	+	/**
521	+	* Checks that thread does not terminate within the given millisecond delay.
522	+	*/
523	+	void assertThreadStaysAlive(Thread thread, long millis) {
524	+	try {
525	+	// No need to optimize the failing case via Thread.join.
526	+	delay(millis);
527	+	assertTrue(thread.isAlive());
528	+	} catch (InterruptedException ie) {
529	+	fail("Unexpected InterruptedException");
530	+	}
531	+	}
532	+
533	+	/**
534	+	* Checks that the threads do not terminate within the default
535	+	* millisecond delay of {@code timeoutMillis()}.
536	+	*/
537	+	void assertThreadsStayAlive(Thread... threads) {
538	+	assertThreadsStayAlive(timeoutMillis(), threads);
539	+	}
540	+
541	+	/**
542	+	* Checks that the threads do not terminate within the given millisecond delay.
543	+	*/
544	+	void assertThreadsStayAlive(long millis, Thread... threads) {
545	+	try {
546	+	// No need to optimize the failing case via Thread.join.
547	+	delay(millis);
548	+	for (Thread thread : threads)
549	+	assertTrue(thread.isAlive());
550	+	} catch (InterruptedException ie) {
551	+	fail("Unexpected InterruptedException");
552	+	}
553	+	}
554	+
555	+	/**
556	+	* Checks that future.get times out, with the default timeout of
557	+	* {@code timeoutMillis()}.
558	+	*/
559	+	void assertFutureTimesOut(Future future) {
560	+	assertFutureTimesOut(future, timeoutMillis());
561	+	}
562	+
563	+	/**
564	+	* Checks that future.get times out, with the given millisecond timeout.
565	+	*/
566	+	void assertFutureTimesOut(Future future, long timeoutMillis) {
567	+	long startTime = System.nanoTime();
568	+	try {
569	+	future.get(timeoutMillis, MILLISECONDS);
570	+	shouldThrow();
571	+	} catch (TimeoutException success) {
572	+	} catch (Exception e) {
573	+	threadUnexpectedException(e);
574	+	} finally { future.cancel(true); }
575	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
576	+	}
577
578		/**
579		* Fails with message "should throw exception".
#	Line 509 | Line 626 | public class JSR166TestCase extends Test
626		SecurityManager sm = System.getSecurityManager();
627		if (sm == null) {
628		r.run();
629	+	}
630	+	runWithSecurityManagerWithPermissions(r, permissions);
631	+	}
632	+
633	+	/**
634	+	* Runs Runnable r with a security policy that permits precisely
635	+	* the specified permissions.  If there is no current security
636	+	* manager, a temporary one is set for the duration of the
637	+	* Runnable.  We require that any security manager permit
638	+	* getPolicy/setPolicy.
639	+	*/
640	+	public void runWithSecurityManagerWithPermissions(Runnable r,
641	+	Permission... permissions) {
642	+	SecurityManager sm = System.getSecurityManager();
643	+	if (sm == null) {
644		Policy savedPolicy = Policy.getPolicy();
645		try {
646		Policy.setPolicy(permissivePolicy());
647		System.setSecurityManager(new SecurityManager());
648	<	runWithPermissions(r, permissions);
648	>	runWithSecurityManagerWithPermissions(r, permissions);
649		} finally {
650		System.setSecurityManager(null);
651		Policy.setPolicy(savedPolicy);
#	Line 561 | Line 693 | public class JSR166TestCase extends Test
693		return perms.implies(p);
694		}
695		public void refresh() {}
696	+	public String toString() {
697	+	List<Permission> ps = new ArrayList<Permission>();
698	+	for (Enumeration<Permission> e = perms.elements(); e.hasMoreElements();)
699	+	ps.add(e.nextElement());
700	+	return "AdjustablePolicy with permissions " + ps;
701	+	}
702		}
703
704		/**
#	Line 588 | Line 726 | public class JSR166TestCase extends Test
726		*/
727		void sleep(long millis) {
728		try {
729	<	Thread.sleep(millis);
729	>	delay(millis);
730		} catch (InterruptedException ie) {
731		AssertionFailedError afe =
732		new AssertionFailedError("Unexpected InterruptedException");
#	Line 598 | Line 736 | public class JSR166TestCase extends Test
736		}
737
738		/**
739	<	* Sleeps until the timeout has elapsed, or interrupted.
602	<	* Does <em>NOT</em> throw InterruptedException.
603	<	*/
604	<	void sleepTillInterrupted(long timeoutMillis) {
605	<	try {
606	<	Thread.sleep(timeoutMillis);
607	<	} catch (InterruptedException wakeup) {}
608	<	}
609	<
610	<	/**
611	<	* Waits up to the specified number of milliseconds for the given
739	>	* Spin-waits up to the specified number of milliseconds for the given
740		* thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
741		*/
742		void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
743	<	long timeoutNanos = timeoutMillis * 1000L * 1000L;
616	<	long t0 = System.nanoTime();
743	>	long startTime = System.nanoTime();
744		for (;;) {
745		Thread.State s = thread.getState();
746		if (s == Thread.State.BLOCKED ||
#	Line 622 | Line 749 | public class JSR166TestCase extends Test
749		return;
750		else if (s == Thread.State.TERMINATED)
751		fail("Unexpected thread termination");
752	<	else if (System.nanoTime() - t0 > timeoutNanos) {
752	>	else if (millisElapsedSince(startTime) > timeoutMillis) {
753		threadAssertTrue(thread.isAlive());
754		return;
755		}
#	Line 631 | Line 758 | public class JSR166TestCase extends Test
758		}
759
760		/**
761	+	* Waits up to LONG_DELAY_MS for the given thread to enter a wait
762	+	* state: BLOCKED, WAITING, or TIMED_WAITING.
763	+	*/
764	+	void waitForThreadToEnterWaitState(Thread thread) {
765	+	waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
766	+	}
767	+
768	+	/**
769		* Returns the number of milliseconds since time given by
770		* startNanoTime, which must have been previously returned from a
771		* call to {@link System.nanoTime()}.
#	Line 660 | Line 795 | public class JSR166TestCase extends Test
795		} catch (InterruptedException ie) {
796		threadUnexpectedException(ie);
797		} finally {
798	<	if (t.isAlive()) {
798	>	if (t.getState() != Thread.State.TERMINATED) {
799		t.interrupt();
800		fail("Test timed out");
801		}
802		}
803		}
804
805	+	/**
806	+	* Waits for LONG_DELAY_MS milliseconds for the thread to
807	+	* terminate (using {@link Thread#join(long)}), else interrupts
808	+	* the thread (in the hope that it may terminate later) and fails.
809	+	*/
810	+	void awaitTermination(Thread t) {
811	+	awaitTermination(t, LONG_DELAY_MS);
812	+	}
813	+
814		// Some convenient Runnable classes
815
816		public abstract class CheckedRunnable implements Runnable {
#	Line 729 | Line 873 | public class JSR166TestCase extends Test
873		realRun();
874		threadShouldThrow("InterruptedException");
875		} catch (InterruptedException success) {
876	+	threadAssertFalse(Thread.interrupted());
877		} catch (Throwable t) {
878		threadUnexpectedException(t);
879		}
#	Line 758 | Line 903 | public class JSR166TestCase extends Test
903		threadShouldThrow("InterruptedException");
904		return result;
905		} catch (InterruptedException success) {
906	+	threadAssertFalse(Thread.interrupted());
907		} catch (Throwable t) {
908		threadUnexpectedException(t);
909		}
#	Line 789 | Line 935 | public class JSR166TestCase extends Test
935		}};
936		}
937
938	+	public Runnable awaiter(final CountDownLatch latch) {
939	+	return new CheckedRunnable() {
940	+	public void realRun() throws InterruptedException {
941	+	await(latch);
942	+	}};
943	+	}
944	+
945	+	public void await(CountDownLatch latch) {
946	+	try {
947	+	assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
948	+	} catch (Throwable t) {
949	+	threadUnexpectedException(t);
950	+	}
951	+	}
952	+
953	+	public void await(Semaphore semaphore) {
954	+	try {
955	+	assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
956	+	} catch (Throwable t) {
957	+	threadUnexpectedException(t);
958	+	}
959	+	}
960	+
961	+	//     /**
962	+	//      * Spin-waits up to LONG_DELAY_MS until flag becomes true.
963	+	//      */
964	+	//     public void await(AtomicBoolean flag) {
965	+	//         await(flag, LONG_DELAY_MS);
966	+	//     }
967	+
968	+	//     /**
969	+	//      * Spin-waits up to the specified timeout until flag becomes true.
970	+	//      */
971	+	//     public void await(AtomicBoolean flag, long timeoutMillis) {
972	+	//         long startTime = System.nanoTime();
973	+	//         while (!flag.get()) {
974	+	//             if (millisElapsedSince(startTime) > timeoutMillis)
975	+	//                 throw new AssertionFailedError("timed out");
976	+	//             Thread.yield();
977	+	//         }
978	+	//     }
979	+
980		public static class NPETask implements Callable<String> {
981		public String call() { throw new NullPointerException(); }
982		}
#	Line 799 | Line 987 | public class JSR166TestCase extends Test
987
988		public class ShortRunnable extends CheckedRunnable {
989		protected void realRun() throws Throwable {
990	<	Thread.sleep(SHORT_DELAY_MS);
990	>	delay(SHORT_DELAY_MS);
991		}
992		}
993
994		public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
995		protected void realRun() throws InterruptedException {
996	<	Thread.sleep(SHORT_DELAY_MS);
996	>	delay(SHORT_DELAY_MS);
997		}
998		}
999
1000		public class SmallRunnable extends CheckedRunnable {
1001		protected void realRun() throws Throwable {
1002	<	Thread.sleep(SMALL_DELAY_MS);
1002	>	delay(SMALL_DELAY_MS);
1003		}
1004		}
1005
1006		public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1007		protected void realRun() {
1008		try {
1009	<	Thread.sleep(SMALL_DELAY_MS);
1009	>	delay(SMALL_DELAY_MS);
1010		} catch (InterruptedException ok) {}
1011		}
1012		}
1013
1014		public class SmallCallable extends CheckedCallable {
1015		protected Object realCall() throws InterruptedException {
1016	<	Thread.sleep(SMALL_DELAY_MS);
1016	>	delay(SMALL_DELAY_MS);
1017		return Boolean.TRUE;
1018		}
1019		}
1020
1021		public class MediumRunnable extends CheckedRunnable {
1022		protected void realRun() throws Throwable {
1023	<	Thread.sleep(MEDIUM_DELAY_MS);
1023	>	delay(MEDIUM_DELAY_MS);
1024		}
1025		}
1026
1027		public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
1028		protected void realRun() throws InterruptedException {
1029	<	Thread.sleep(MEDIUM_DELAY_MS);
1029	>	delay(MEDIUM_DELAY_MS);
1030		}
1031		}
1032
#	Line 846 | Line 1034 | public class JSR166TestCase extends Test
1034		return new CheckedRunnable() {
1035		protected void realRun() {
1036		try {
1037	<	Thread.sleep(timeoutMillis);
1037	>	delay(timeoutMillis);
1038		} catch (InterruptedException ok) {}
1039		}};
1040		}
#	Line 854 | Line 1042 | public class JSR166TestCase extends Test
1042		public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
1043		protected void realRun() {
1044		try {
1045	<	Thread.sleep(MEDIUM_DELAY_MS);
1045	>	delay(MEDIUM_DELAY_MS);
1046		} catch (InterruptedException ok) {}
1047		}
1048		}
#	Line 862 | Line 1050 | public class JSR166TestCase extends Test
1050		public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
1051		protected void realRun() {
1052		try {
1053	<	Thread.sleep(LONG_DELAY_MS);
1053	>	delay(LONG_DELAY_MS);
1054		} catch (InterruptedException ok) {}
1055		}
1056		}
#	Line 886 | Line 1074 | public class JSR166TestCase extends Test
1074		public boolean isDone() { return done; }
1075		public void run() {
1076		try {
1077	<	Thread.sleep(timeoutMillis);
1077	>	delay(timeoutMillis);
1078		done = true;
1079		} catch (InterruptedException ok) {}
1080		}
#	Line 897 | Line 1085 | public class JSR166TestCase extends Test
1085		public volatile boolean done = false;
1086		public void run() {
1087		try {
1088	<	Thread.sleep(SHORT_DELAY_MS);
1088	>	delay(SHORT_DELAY_MS);
1089		done = true;
1090		} catch (InterruptedException ok) {}
1091		}
#	Line 907 | Line 1095 | public class JSR166TestCase extends Test
1095		public volatile boolean done = false;
1096		public void run() {
1097		try {
1098	<	Thread.sleep(SMALL_DELAY_MS);
1098	>	delay(SMALL_DELAY_MS);
1099		done = true;
1100		} catch (InterruptedException ok) {}
1101		}
#	Line 917 | Line 1105 | public class JSR166TestCase extends Test
1105		public volatile boolean done = false;
1106		public void run() {
1107		try {
1108	<	Thread.sleep(MEDIUM_DELAY_MS);
1108	>	delay(MEDIUM_DELAY_MS);
1109		done = true;
1110		} catch (InterruptedException ok) {}
1111		}
#	Line 927 | Line 1115 | public class JSR166TestCase extends Test
1115		public volatile boolean done = false;
1116		public void run() {
1117		try {
1118	<	Thread.sleep(LONG_DELAY_MS);
1118	>	delay(LONG_DELAY_MS);
1119		done = true;
1120		} catch (InterruptedException ok) {}
1121		}
#	Line 944 | Line 1132 | public class JSR166TestCase extends Test
1132		public volatile boolean done = false;
1133		public Object call() {
1134		try {
1135	<	Thread.sleep(SMALL_DELAY_MS);
1135	>	delay(SMALL_DELAY_MS);
1136		done = true;
1137		} catch (InterruptedException ok) {}
1138		return Boolean.TRUE;
#	Line 991 | Line 1179 | public class JSR166TestCase extends Test
1179		}
1180
1181		/**
1182	<	* A CyclicBarrier that fails with AssertionFailedErrors instead
1183	<	* of throwing checked exceptions.
1182	>	* A CyclicBarrier that uses timed await and fails with
1183	>	* AssertionFailedErrors instead of throwing checked exceptions.
1184		*/
1185		public class CheckedBarrier extends CyclicBarrier {
1186		public CheckedBarrier(int parties) { super(parties); }
1187
1188		public int await() {
1189		try {
1190	<	return super.await();
1190	>	return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1191	>	} catch (TimeoutException e) {
1192	>	throw new AssertionFailedError("timed out");
1193		} catch (Exception e) {
1194		AssertionFailedError afe =
1195		new AssertionFailedError("Unexpected exception: " + e);
#	Line 1009 | Line 1199 | public class JSR166TestCase extends Test
1199		}
1200		}
1201
1202	<	public void checkEmpty(BlockingQueue q) {
1202	>	void checkEmpty(BlockingQueue q) {
1203		try {
1204		assertTrue(q.isEmpty());
1205		assertEquals(0, q.size());
#	Line 1036 | Line 1226 | public class JSR166TestCase extends Test
1226		}
1227		}
1228
1229	+	void assertSerialEquals(Object x, Object y) {
1230	+	assertTrue(Arrays.equals(serialBytes(x), serialBytes(y)));
1231	+	}
1232	+
1233	+	void assertNotSerialEquals(Object x, Object y) {
1234	+	assertFalse(Arrays.equals(serialBytes(x), serialBytes(y)));
1235	+	}
1236	+
1237	+	byte[] serialBytes(Object o) {
1238	+	try {
1239	+	ByteArrayOutputStream bos = new ByteArrayOutputStream();
1240	+	ObjectOutputStream oos = new ObjectOutputStream(bos);
1241	+	oos.writeObject(o);
1242	+	oos.flush();
1243	+	oos.close();
1244	+	return bos.toByteArray();
1245	+	} catch (Throwable t) {
1246	+	threadUnexpectedException(t);
1247	+	return new byte[0];
1248	+	}
1249	+	}
1250	+
1251	+	@SuppressWarnings("unchecked")
1252	+	<T> T serialClone(T o) {
1253	+	try {
1254	+	ObjectInputStream ois = new ObjectInputStream
1255	+	(new ByteArrayInputStream(serialBytes(o)));
1256	+	T clone = (T) ois.readObject();
1257	+	assertSame(o.getClass(), clone.getClass());
1258	+	return clone;
1259	+	} catch (Throwable t) {
1260	+	threadUnexpectedException(t);
1261	+	return null;
1262	+	}
1263	+	}
1264		}

Diff Legend

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