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.43 by jsr166, Sat Nov 21 10:25:05 2009 UTC vs.
Revision 1.51 by jsr166, Wed Sep 1 06:41:55 2010 UTC

#	Line 26 | Line 26 | import java.security.*;
26		* <li> All assertions in code running in generated threads must use
27		* the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link
28		* #threadAssertEquals}, or {@link #threadAssertNull}, (not
29	<	* <tt>fail</tt>, <tt>assertTrue</tt>, etc.) It is OK (but not
29	>	* {@code fail}, {@code assertTrue}, etc.) It is OK (but not
30		* particularly recommended) for other code to use these forms too.
31		* Only the most typically used JUnit assertion methods are defined
32		* this way, but enough to live with.</li>
33		*
34		* <li> If you override {@link #setUp} or {@link #tearDown}, make sure
35	<	* to invoke <tt>super.setUp</tt> and <tt>super.tearDown</tt> within
35	>	* to invoke {@code super.setUp} and {@code super.tearDown} within
36		* them. These methods are used to clear and check for thread
37		* assertion failures.</li>
38		*
39	<	* <li>All delays and timeouts must use one of the constants <tt>
40	<	* SHORT_DELAY_MS</tt>, <tt> SMALL_DELAY_MS</tt>, <tt> MEDIUM_DELAY_MS</tt>,
41	<	* <tt> LONG_DELAY_MS</tt>. The idea here is that a SHORT is always
39	>	* <li>All delays and timeouts must use one of the constants {@code
40	>	* SHORT_DELAY_MS}, {@code SMALL_DELAY_MS}, {@code MEDIUM_DELAY_MS},
41	>	* {@code LONG_DELAY_MS}. The idea here is that a SHORT is always
42		* discriminable from zero time, and always allows enough time for the
43		* small amounts of computation (creating a thread, calling a few
44		* methods, etc) needed to reach a timeout point. Similarly, a SMALL
#	Line 48 | Line 48 | import java.security.*;
48		* in one spot to rerun tests on slower platforms.</li>
49		*
50		* <li> All threads generated must be joined inside each test case
51	<	* method (or <tt>fail</tt> to do so) before returning from the
52	<	* method. The <tt> joinPool</tt> method can be used to do this when
51	>	* method (or {@code fail} to do so) before returning from the
52	>	* method. The {@code joinPool} method can be used to do this when
53		* using Executors.</li>
54		*
55		* </ol>
#	Line 81 | Line 81 | import java.security.*;
81		* any particular package to simplify things for people integrating
82		* them in TCK test suites.</li>
83		*
84	<	* <li> As a convenience, the <tt>main</tt> of this class (JSR166TestCase)
84	>	* <li> As a convenience, the {@code main} of this class (JSR166TestCase)
85		* runs all JSR166 unit tests.</li>
86		*
87		* </ul>
88		*/
89		public class JSR166TestCase extends TestCase {
90	+	private static final boolean useSecurityManager =
91	+	Boolean.getBoolean("jsr166.useSecurityManager");
92	+
93		/**
94		* Runs all JSR166 unit tests using junit.textui.TestRunner
95		*/
96		public static void main(String[] args) {
97	+	if (useSecurityManager) {
98	+	System.err.println("Setting a permissive security manager");
99	+	Policy.setPolicy(permissivePolicy());
100	+	System.setSecurityManager(new SecurityManager());
101	+	}
102		int iters = 1;
103		if (args.length > 0)
104		iters = Integer.parseInt(args[0]);
#	Line 135 | Line 143 | public class JSR166TestCase extends Test
143		suite.addTest(new TestSuite(AtomicReferenceTest.class));
144		suite.addTest(new TestSuite(AtomicStampedReferenceTest.class));
145		suite.addTest(new TestSuite(ConcurrentHashMapTest.class));
146	+	suite.addTest(new TestSuite(ConcurrentLinkedDequeTest.class));
147		suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.class));
148		suite.addTest(new TestSuite(ConcurrentSkipListMapTest.class));
149		suite.addTest(new TestSuite(ConcurrentSkipListSubMapTest.class));
#	Line 328 | Line 337 | public class JSR166TestCase extends Test
337		} catch (SecurityException ok) {
338		// Allowed in case test doesn't have privs
339		} catch (InterruptedException ie) {
340	<	fail("Unexpected exception");
340	>	fail("Unexpected InterruptedException");
341		}
342		}
343
#	Line 366 | Line 375 | public class JSR166TestCase extends Test
375		/**
376		* The number of elements to place in collections, arrays, etc.
377		*/
378	<	static final int SIZE = 20;
378	>	public static final int SIZE = 20;
379
380		// Some convenient Integer constants
381
382	<	static final Integer zero = new Integer(0);
383	<	static final Integer one = new Integer(1);
384	<	static final Integer two = new Integer(2);
385	<	static final Integer three  = new Integer(3);
386	<	static final Integer four  = new Integer(4);
387	<	static final Integer five  = new Integer(5);
388	<	static final Integer six = new Integer(6);
389	<	static final Integer seven = new Integer(7);
390	<	static final Integer eight = new Integer(8);
391	<	static final Integer nine = new Integer(9);
392	<	static final Integer m1  = new Integer(-1);
393	<	static final Integer m2  = new Integer(-2);
394	<	static final Integer m3  = new Integer(-3);
395	<	static final Integer m4 = new Integer(-4);
396	<	static final Integer m5 = new Integer(-5);
397	<	static final Integer m6 = new Integer(-6);
398	<	static final Integer m10 = new Integer(-10);
382	>	public static final Integer zero  = new Integer(0);
383	>	public static final Integer one   = new Integer(1);
384	>	public static final Integer two   = new Integer(2);
385	>	public static final Integer three = new Integer(3);
386	>	public static final Integer four  = new Integer(4);
387	>	public static final Integer five  = new Integer(5);
388	>	public static final Integer six   = new Integer(6);
389	>	public static final Integer seven = new Integer(7);
390	>	public static final Integer eight = new Integer(8);
391	>	public static final Integer nine  = new Integer(9);
392	>	public static final Integer m1  = new Integer(-1);
393	>	public static final Integer m2  = new Integer(-2);
394	>	public static final Integer m3  = new Integer(-3);
395	>	public static final Integer m4  = new Integer(-4);
396	>	public static final Integer m5  = new Integer(-5);
397	>	public static final Integer m6  = new Integer(-6);
398	>	public static final Integer m10 = new Integer(-10);
399	>
400	>
401	>	/**
402	>	* Runs Runnable r with a security policy that permits precisely
403	>	* the specified permissions.  If there is no current security
404	>	* manager, the runnable is run twice, both with and without a
405	>	* security manager.  We require that any security manager permit
406	>	* getPolicy/setPolicy.
407	>	*/
408	>	public void runWithPermissions(Runnable r, Permission... permissions) {
409	>	SecurityManager sm = System.getSecurityManager();
410	>	if (sm == null) {
411	>	r.run();
412	>	Policy savedPolicy = Policy.getPolicy();
413	>	try {
414	>	Policy.setPolicy(permissivePolicy());
415	>	System.setSecurityManager(new SecurityManager());
416	>	runWithPermissions(r, permissions);
417	>	} finally {
418	>	System.setSecurityManager(null);
419	>	Policy.setPolicy(savedPolicy);
420	>	}
421	>	} else {
422	>	Policy savedPolicy = Policy.getPolicy();
423	>	AdjustablePolicy policy = new AdjustablePolicy(permissions);
424	>	Policy.setPolicy(policy);
425	>
426	>	try {
427	>	r.run();
428	>	} finally {
429	>	policy.addPermission(new SecurityPermission("setPolicy"));
430	>	Policy.setPolicy(savedPolicy);
431	>	}
432	>	}
433	>	}
434
435	+	/**
436	+	* Runs a runnable without any permissions.
437	+	*/
438	+	public void runWithoutPermissions(Runnable r) {
439	+	runWithPermissions(r);
440	+	}
441
442		/**
443		* A security policy where new permissions can be dynamically added
444		* or all cleared.
445		*/
446	<	static class AdjustablePolicy extends java.security.Policy {
446	>	public static class AdjustablePolicy extends java.security.Policy {
447		Permissions perms = new Permissions();
448	<	AdjustablePolicy() { }
448	>	AdjustablePolicy(Permission... permissions) {
449	>	for (Permission permission : permissions)
450	>	perms.add(permission);
451	>	}
452		void addPermission(Permission perm) { perms.add(perm); }
453		void clearPermissions() { perms = new Permissions(); }
454		public PermissionCollection getPermissions(CodeSource cs) {
#	Line 411 | Line 464 | public class JSR166TestCase extends Test
464		}
465
466		/**
467	+	* Returns a policy containing all the permissions we ever need.
468	+	*/
469	+	public static Policy permissivePolicy() {
470	+	return new AdjustablePolicy
471	+	// Permissions j.u.c. needs directly
472	+	(new RuntimePermission("modifyThread"),
473	+	new RuntimePermission("getClassLoader"),
474	+	new RuntimePermission("setContextClassLoader"),
475	+	// Permissions needed to change permissions!
476	+	new SecurityPermission("getPolicy"),
477	+	new SecurityPermission("setPolicy"),
478	+	new RuntimePermission("setSecurityManager"),
479	+	// Permissions needed by the junit test harness
480	+	new RuntimePermission("accessDeclaredMembers"),
481	+	new PropertyPermission("*", "read"),
482	+	new java.io.FilePermission("<<ALL FILES>>", "read"));
483	+	}
484	+
485	+	/**
486		* Sleep until the timeout has elapsed, or interrupted.
487		* Does <em>NOT</em> throw InterruptedException.
488		*/
489		void sleepTillInterrupted(long timeoutMillis) {
490		try {
491		Thread.sleep(timeoutMillis);
492	<	} catch (InterruptedException wakeup) {
421	<	}
492	>	} catch (InterruptedException wakeup) {}
493		}
494
495		/**
#	Line 432 | Line 503 | public class JSR166TestCase extends Test
503
504		// Some convenient Runnable classes
505
506	<	abstract class CheckedRunnable implements Runnable {
507	<	abstract void realRun() throws Throwable;
506	>	public abstract class CheckedRunnable implements Runnable {
507	>	protected abstract void realRun() throws Throwable;
508
509		public final void run() {
510		try {
#	Line 444 | Line 515 | public class JSR166TestCase extends Test
515		}
516		}
517
518	<	abstract class RunnableShouldThrow implements Runnable {
519	<	abstract void realRun() throws Throwable;
518	>	public abstract class RunnableShouldThrow implements Runnable {
519	>	protected abstract void realRun() throws Throwable;
520
521		final Class<?> exceptionClass;
522
#	Line 457 | Line 528 | public class JSR166TestCase extends Test
528		try {
529		realRun();
530		threadShouldThrow(exceptionClass.getSimpleName());
460	–	} catch (InterruptedException success) {
531		} catch (Throwable t) {
532		if (! exceptionClass.isInstance(t))
533		threadUnexpectedException(t);
#	Line 465 | Line 535 | public class JSR166TestCase extends Test
535		}
536		}
537
538	<	abstract class ThreadShouldThrow extends Thread {
539	<	abstract void realRun() throws Throwable;
538	>	public abstract class ThreadShouldThrow extends Thread {
539	>	protected abstract void realRun() throws Throwable;
540
541		final Class<?> exceptionClass;
542
#	Line 478 | Line 548 | public class JSR166TestCase extends Test
548		try {
549		realRun();
550		threadShouldThrow(exceptionClass.getSimpleName());
481	–	} catch (InterruptedException success) {
551		} catch (Throwable t) {
552		if (! exceptionClass.isInstance(t))
553		threadUnexpectedException(t);
#	Line 486 | Line 555 | public class JSR166TestCase extends Test
555		}
556		}
557
558	<	abstract class CheckedInterruptedRunnable implements Runnable {
559	<	abstract void realRun() throws Throwable;
558	>	public abstract class CheckedInterruptedRunnable implements Runnable {
559	>	protected abstract void realRun() throws Throwable;
560
561		public final void run() {
562		try {
#	Line 500 | Line 569 | public class JSR166TestCase extends Test
569		}
570		}
571
572	<	abstract class CheckedCallable<T> implements Callable<T> {
573	<	abstract T realCall() throws Throwable;
572	>	public abstract class CheckedCallable<T> implements Callable<T> {
573	>	protected abstract T realCall() throws Throwable;
574
575		public final T call() {
576		try {
#	Line 513 | Line 582 | public class JSR166TestCase extends Test
582		}
583		}
584
585	<	abstract class CheckedInterruptedCallable<T> implements Callable<T> {
586	<	abstract T realCall() throws Throwable;
585	>	public abstract class CheckedInterruptedCallable<T> implements Callable<T> {
586	>	protected abstract T realCall() throws Throwable;
587
588		public final T call() {
589		try {
#	Line 529 | Line 598 | public class JSR166TestCase extends Test
598		}
599		}
600
601	<	static class NoOpRunnable implements Runnable {
601	>	public static class NoOpRunnable implements Runnable {
602		public void run() {}
603		}
604
605	<	static class NoOpCallable implements Callable {
605	>	public static class NoOpCallable implements Callable {
606		public Object call() { return Boolean.TRUE; }
607		}
608
609	<	static final String TEST_STRING = "a test string";
609	>	public static final String TEST_STRING = "a test string";
610
611	<	static class StringTask implements Callable<String> {
611	>	public static class StringTask implements Callable<String> {
612		public String call() { return TEST_STRING; }
613		}
614
615	<	static class NPETask implements Callable<String> {
615	>	public Callable<String> latchAwaitingStringTask(final CountDownLatch latch) {
616	>	return new CheckedCallable<String>() {
617	>	public String realCall() {
618	>	try {
619	>	latch.await();
620	>	} catch (InterruptedException quittingTime) {}
621	>	return TEST_STRING;
622	>	}};
623	>	}
624	>
625	>	public static class NPETask implements Callable<String> {
626		public String call() { throw new NullPointerException(); }
627		}
628
629	<	static class CallableOne implements Callable<Integer> {
629	>	public static class CallableOne implements Callable<Integer> {
630		public Integer call() { return one; }
631		}
632
633	<	class ShortRunnable extends CheckedRunnable {
634	<	void realRun() throws Throwable {
633	>	public class ShortRunnable extends CheckedRunnable {
634	>	protected void realRun() throws Throwable {
635		Thread.sleep(SHORT_DELAY_MS);
636		}
637		}
638
639	<	class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
640	<	void realRun() throws InterruptedException {
639	>	public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
640	>	protected void realRun() throws InterruptedException {
641		Thread.sleep(SHORT_DELAY_MS);
642		}
643		}
644
645	<	class SmallRunnable extends CheckedRunnable {
646	<	void realRun() throws Throwable {
645	>	public class SmallRunnable extends CheckedRunnable {
646	>	protected void realRun() throws Throwable {
647		Thread.sleep(SMALL_DELAY_MS);
648		}
649		}
650
651	<	class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
652	<	void realRun() {
651	>	public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
652	>	protected void realRun() {
653		try {
654		Thread.sleep(SMALL_DELAY_MS);
655	<	}
577	<	catch (InterruptedException ok) {
578	<	}
655	>	} catch (InterruptedException ok) {}
656		}
657		}
658
659	<	class SmallCallable extends CheckedCallable {
660	<	Object realCall() throws Throwable {
659	>	public class SmallCallable extends CheckedCallable {
660	>	protected Object realCall() throws InterruptedException {
661		Thread.sleep(SMALL_DELAY_MS);
662		return Boolean.TRUE;
663		}
664		}
665
666	<	class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
667	<	void realRun() throws InterruptedException {
666	>	public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
667	>	protected void realRun() throws InterruptedException {
668		Thread.sleep(SMALL_DELAY_MS);
669		}
670		}
671
672	<	class MediumRunnable extends CheckedRunnable {
673	<	void realRun() throws Throwable {
672	>	public class MediumRunnable extends CheckedRunnable {
673	>	protected void realRun() throws Throwable {
674		Thread.sleep(MEDIUM_DELAY_MS);
675		}
676		}
677
678	<	class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
679	<	void realRun() throws InterruptedException {
678	>	public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
679	>	protected void realRun() throws InterruptedException {
680		Thread.sleep(MEDIUM_DELAY_MS);
681		}
682		}
683
684	<	class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
685	<	void realRun() {
684	>	public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
685	>	protected void realRun() {
686		try {
687		Thread.sleep(MEDIUM_DELAY_MS);
688	<	}
612	<	catch (InterruptedException ok) {
613	<	}
688	>	} catch (InterruptedException ok) {}
689		}
690		}
691
692	<	class LongPossiblyInterruptedRunnable extends CheckedRunnable {
693	<	void realRun() {
692	>	public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
693	>	protected void realRun() {
694		try {
695		Thread.sleep(LONG_DELAY_MS);
696	<	}
622	<	catch (InterruptedException ok) {
623	<	}
696	>	} catch (InterruptedException ok) {}
697		}
698		}
699
700		/**
701		* For use as ThreadFactory in constructors
702		*/
703	<	static class SimpleThreadFactory implements ThreadFactory {
703	>	public static class SimpleThreadFactory implements ThreadFactory {
704		public Thread newThread(Runnable r) {
705		return new Thread(r);
706		}
707		}
708
709	<	static class TrackedShortRunnable implements Runnable {
710	<	volatile boolean done = false;
709	>	public static class TrackedShortRunnable implements Runnable {
710	>	public volatile boolean done = false;
711		public void run() {
712		try {
713		Thread.sleep(SMALL_DELAY_MS);
714		done = true;
715	<	} catch (InterruptedException ok) {
643	<	}
715	>	} catch (InterruptedException ok) {}
716		}
717		}
718
719	<	static class TrackedMediumRunnable implements Runnable {
720	<	volatile boolean done = false;
719	>	public static class TrackedMediumRunnable implements Runnable {
720	>	public volatile boolean done = false;
721		public void run() {
722		try {
723		Thread.sleep(MEDIUM_DELAY_MS);
724		done = true;
725	<	} catch (InterruptedException ok) {
654	<	}
725	>	} catch (InterruptedException ok) {}
726		}
727		}
728
729	<	static class TrackedLongRunnable implements Runnable {
730	<	volatile boolean done = false;
729	>	public static class TrackedLongRunnable implements Runnable {
730	>	public volatile boolean done = false;
731		public void run() {
732		try {
733		Thread.sleep(LONG_DELAY_MS);
734		done = true;
735	<	} catch (InterruptedException ok) {
665	<	}
735	>	} catch (InterruptedException ok) {}
736		}
737		}
738
739	<	static class TrackedNoOpRunnable implements Runnable {
740	<	volatile boolean done = false;
739	>	public static class TrackedNoOpRunnable implements Runnable {
740	>	public volatile boolean done = false;
741		public void run() {
742		done = true;
743		}
744		}
745
746	<	static class TrackedCallable implements Callable {
747	<	volatile boolean done = false;
746	>	public static class TrackedCallable implements Callable {
747	>	public volatile boolean done = false;
748		public Object call() {
749		try {
750		Thread.sleep(SMALL_DELAY_MS);
751		done = true;
752	<	} catch (InterruptedException ok) {
683	<	}
752	>	} catch (InterruptedException ok) {}
753		return Boolean.TRUE;
754		}
755		}
#	Line 689 | Line 758 | public class JSR166TestCase extends Test
758		/**
759		* For use as RejectedExecutionHandler in constructors
760		*/
761	<	static class NoOpREHandler implements RejectedExecutionHandler {
761	>	public static class NoOpREHandler implements RejectedExecutionHandler {
762		public void rejectedExecution(Runnable r,
763		ThreadPoolExecutor executor) {}
764		}

Diff Legend

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