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.78 by jsr166, Sat May 7 19:03:26 2011 UTC vs.
Revision 1.93 by jsr166, Sun Dec 16 17:22:42 2012 UTC

#	Line 7 | Line 7
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
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	<	public static void delay(long ms) throws InterruptedException {
481	>	static void delay(long millis) throws InterruptedException {
482		long startTime = System.nanoTime();
483	<	long ns = ms * 1000 * 1000;
483	>	long ns = millis * 1000 * 1000;
484		for (;;) {
485	<	if (ms > 0L)
486	<	Thread.sleep(ms);
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	<	ms = d / (1000 * 1000);
491	>	millis = d / (1000 * 1000);
492		else
493		break;
494		}
#	Line 466 | Line 497 | public class JSR166TestCase extends Test
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 479 | Line 510 | public class JSR166TestCase extends Test
510		}
511
512		/**
513	<	* Checks that thread does not terminate within timeoutMillis
514	<	* milliseconds (that is, Thread.join times out).
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	<	public void assertThreadJoinTimesOut(Thread thread, long timeoutMillis) {
523	>	void assertThreadStaysAlive(Thread thread, long millis) {
524		try {
525	<	long startTime = System.nanoTime();
526	<	thread.join(timeoutMillis);
525	>	// No need to optimize the failing case via Thread.join.
526	>	delay(millis);
527		assertTrue(thread.isAlive());
490	–	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
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".
580		*/
581		public void shouldThrow() {
#	Line 544 | 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 596 | 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 633 | Line 736 | public class JSR166TestCase extends Test
736		}
737
738		/**
739	<	* Sleeps until the timeout has elapsed, or interrupted.
637	<	* Does <em>NOT</em> throw InterruptedException.
638	<	*/
639	<	void sleepTillInterrupted(long timeoutMillis) {
640	<	try {
641	<	Thread.sleep(timeoutMillis);
642	<	} catch (InterruptedException wakeup) {}
643	<	}
644	<
645	<	/**
646	<	* 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;
651	<	long t0 = System.nanoTime();
743	>	long startTime = System.nanoTime();
744		for (;;) {
745		Thread.State s = thread.getState();
746		if (s == Thread.State.BLOCKED ||
#	Line 657 | 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 703 | 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		}
#	Line 781 | 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 810 | 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 844 | Line 938 | public class JSR166TestCase extends Test
938		public Runnable awaiter(final CountDownLatch latch) {
939		return new CheckedRunnable() {
940		public void realRun() throws InterruptedException {
941	<	latch.await();
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 1050 | 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 1068 | 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 1095 | 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