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.32 by dl, Fri Jul 31 23:02:49 2009 UTC vs.
Revision 1.45 by jsr166, Thu Nov 26 15:42:15 2009 UTC

#	Line 9 | Line 9
9		import junit.framework.*;
10		import java.util.*;
11		import java.util.concurrent.*;
12	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13		import java.io.*;
14		import java.security.*;
15
#	Line 89 | Line 90 | public class JSR166TestCase extends Test
90		/**
91		* Runs all JSR166 unit tests using junit.textui.TestRunner
92		*/
93	<	public static void main (String[] args) {
93	>	public static void main(String[] args) {
94		int iters = 1;
95		if (args.length > 0)
96		iters = Integer.parseInt(args[0]);
97		Test s = suite();
98		for (int i = 0; i < iters; ++i) {
99	<	junit.textui.TestRunner.run (s);
99	>	junit.textui.TestRunner.run(s);
100		System.gc();
101		System.runFinalization();
102		}
#	Line 105 | Line 106 | public class JSR166TestCase extends Test
106		/**
107		* Collects all JSR166 unit tests as one suite
108		*/
109	<	public static Test suite ( ) {
109	>	public static Test suite() {
110		TestSuite suite = new TestSuite("JSR166 Unit Tests");
111
112		suite.addTest(new TestSuite(ForkJoinPoolTest.class));
#	Line 194 | Line 195 | public class JSR166TestCase extends Test
195		/**
196		* Sets delays as multiples of SHORT_DELAY.
197		*/
198	<	protected  void setDelays() {
198	>	protected void setDelays() {
199		SHORT_DELAY_MS = getShortDelay();
200		SMALL_DELAY_MS = SHORT_DELAY_MS * 5;
201		MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10;
#	Line 286 | Line 287 | public class JSR166TestCase extends Test
287
288		/**
289		* threadFail with message "should throw exception"
290	<	*/
290	>	*/
291		public void threadShouldThrow() {
292	<	try {
293	<	threadFailed = true;
294	<	fail("should throw exception");
295	<	} catch (AssertionFailedError e) {
296	<	e.printStackTrace();
297	<	throw e;
298	<	}
292	>	threadFailed = true;
293	>	fail("should throw exception");
294	>	}
295	>
296	>	/**
297	>	* threadFail with message "should throw" + exceptionName
298	>	*/
299	>	public void threadShouldThrow(String exceptionName) {
300	>	threadFailed = true;
301	>	fail("should throw " + exceptionName);
302		}
303
304		/**
#	Line 320 | Line 324 | public class JSR166TestCase extends Test
324		public void joinPool(ExecutorService exec) {
325		try {
326		exec.shutdown();
327	<	assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
328	<	} catch(SecurityException ok) {
327	>	assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
328	>	} catch (SecurityException ok) {
329		// Allowed in case test doesn't have privs
330	<	} catch(InterruptedException ie) {
331	<	fail("Unexpected exception");
330	>	} catch (InterruptedException ie) {
331	>	fail("Unexpected InterruptedException");
332		}
333		}
334
#	Line 337 | Line 341 | public class JSR166TestCase extends Test
341		}
342
343		/**
344	+	* fail with message "should throw " + exceptionName
345	+	*/
346	+	public void shouldThrow(String exceptionName) {
347	+	fail("Should throw " + exceptionName);
348	+	}
349	+
350	+	/**
351		* fail with message "Unexpected exception"
352		*/
353		public void unexpectedException() {
354		fail("Unexpected exception");
355		}
356
357	+	/**
358	+	* fail with message "Unexpected exception", with argument
359	+	*/
360	+	public void unexpectedException(Throwable ex) {
361	+	ex.printStackTrace();
362	+	fail("Unexpected exception: " + ex);
363	+	}
364	+
365
366		/**
367		* The number of elements to place in collections, arrays, etc.
368		*/
369	<	static final int SIZE = 20;
369	>	public static final int SIZE = 20;
370
371		// Some convenient Integer constants
372
373	<	static final Integer zero = new Integer(0);
374	<	static final Integer one = new Integer(1);
375	<	static final Integer two = new Integer(2);
376	<	static final Integer three  = new Integer(3);
377	<	static final Integer four  = new Integer(4);
378	<	static final Integer five  = new Integer(5);
379	<	static final Integer six = new Integer(6);
380	<	static final Integer seven = new Integer(7);
381	<	static final Integer eight = new Integer(8);
382	<	static final Integer nine = new Integer(9);
383	<	static final Integer m1  = new Integer(-1);
384	<	static final Integer m2  = new Integer(-2);
385	<	static final Integer m3  = new Integer(-3);
386	<	static final Integer m4 = new Integer(-4);
387	<	static final Integer m5 = new Integer(-5);
388	<	static final Integer m6 = new Integer(-6);
389	<	static final Integer m10 = new Integer(-10);
373	>	public static final Integer zero = new Integer(0);
374	>	public static final Integer one = new Integer(1);
375	>	public static final Integer two = new Integer(2);
376	>	public static final Integer three  = new Integer(3);
377	>	public static final Integer four  = new Integer(4);
378	>	public static final Integer five  = new Integer(5);
379	>	public static final Integer six = new Integer(6);
380	>	public static final Integer seven = new Integer(7);
381	>	public static final Integer eight = new Integer(8);
382	>	public static final Integer nine = new Integer(9);
383	>	public static final Integer m1  = new Integer(-1);
384	>	public static final Integer m2  = new Integer(-2);
385	>	public static final Integer m3  = new Integer(-3);
386	>	public static final Integer m4 = new Integer(-4);
387	>	public static final Integer m5 = new Integer(-5);
388	>	public static final Integer m6 = new Integer(-6);
389	>	public static final Integer m10 = new Integer(-10);
390
391
392		/**
393		* A security policy where new permissions can be dynamically added
394		* or all cleared.
395		*/
396	<	static class AdjustablePolicy extends java.security.Policy {
396	>	public static class AdjustablePolicy extends java.security.Policy {
397		Permissions perms = new Permissions();
398		AdjustablePolicy() { }
399		void addPermission(Permission perm) { perms.add(perm); }
400		void clearPermissions() { perms = new Permissions(); }
401	<	public PermissionCollection getPermissions(CodeSource cs) {
402	<	return perms;
403	<	}
404	<	public PermissionCollection getPermissions(ProtectionDomain pd) {
405	<	return perms;
406	<	}
407	<	public boolean implies(ProtectionDomain pd, Permission p) {
408	<	return perms.implies(p);
409	<	}
410	<	public void refresh() {}
401	>	public PermissionCollection getPermissions(CodeSource cs) {
402	>	return perms;
403	>	}
404	>	public PermissionCollection getPermissions(ProtectionDomain pd) {
405	>	return perms;
406	>	}
407	>	public boolean implies(ProtectionDomain pd, Permission p) {
408	>	return perms.implies(p);
409	>	}
410	>	public void refresh() {}
411		}
412
413	<
414	<	// Some convenient Runnable classes
415	<
416	<	static class NoOpRunnable implements Runnable {
417	<	public void run() {}
413	>	/**
414	>	* Sleep until the timeout has elapsed, or interrupted.
415	>	* Does <em>NOT</em> throw InterruptedException.
416	>	*/
417	>	void sleepTillInterrupted(long timeoutMillis) {
418	>	try {
419	>	Thread.sleep(timeoutMillis);
420	>	} catch (InterruptedException wakeup) {}
421		}
422
423	<	static class NoOpCallable implements Callable {
424	<	public Object call() { return Boolean.TRUE; }
423	>	/**
424	>	* Returns a new started Thread running the given runnable.
425	>	*/
426	>	Thread newStartedThread(Runnable runnable) {
427	>	Thread t = new Thread(runnable);
428	>	t.start();
429	>	return t;
430		}
431
432	<	static final String TEST_STRING = "a test string";
432	>	// Some convenient Runnable classes
433
434	<	static class StringTask implements Callable<String> {
435	<	public String call() { return TEST_STRING; }
409	<	}
434	>	public abstract class CheckedRunnable implements Runnable {
435	>	protected abstract void realRun() throws Throwable;
436
437	<	static class NPETask implements Callable<String> {
438	<	public String call() { throw new NullPointerException(); }
437	>	public final void run() {
438	>	try {
439	>	realRun();
440	>	} catch (Throwable t) {
441	>	threadUnexpectedException(t);
442	>	}
443	>	}
444		}
445
446	<	static class CallableOne implements Callable<Integer> {
447	<	public Integer call() { return one; }
417	<	}
446	>	public abstract class RunnableShouldThrow implements Runnable {
447	>	protected abstract void realRun() throws Throwable;
448
449	<	class ShortRunnable implements Runnable {
450	<	public void run() {
449	>	final Class<?> exceptionClass;
450	>
451	>	<T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) {
452	>	this.exceptionClass = exceptionClass;
453	>	}
454	>
455	>	public final void run() {
456		try {
457	<	Thread.sleep(SHORT_DELAY_MS);
458	<	}
459	<	catch(Exception e) {
460	<	threadUnexpectedException(e);
457	>	realRun();
458	>	threadShouldThrow(exceptionClass.getSimpleName());
459	>	} catch (InterruptedException success) {
460	>	} catch (Throwable t) {
461	>	if (! exceptionClass.isInstance(t))
462	>	threadUnexpectedException(t);
463		}
464		}
465		}
466
467	<	class ShortInterruptedRunnable implements Runnable {
468	<	public void run() {
467	>	public abstract class ThreadShouldThrow extends Thread {
468	>	protected abstract void realRun() throws Throwable;
469	>
470	>	final Class<?> exceptionClass;
471	>
472	>	<T extends Throwable> ThreadShouldThrow(Class<T> exceptionClass) {
473	>	this.exceptionClass = exceptionClass;
474	>	}
475	>
476	>	public final void run() {
477		try {
478	<	Thread.sleep(SHORT_DELAY_MS);
479	<	threadShouldThrow();
480	<	}
481	<	catch(InterruptedException success) {
478	>	realRun();
479	>	threadShouldThrow(exceptionClass.getSimpleName());
480	>	} catch (InterruptedException success) {
481	>	} catch (Throwable t) {
482	>	if (! exceptionClass.isInstance(t))
483	>	threadUnexpectedException(t);
484		}
485		}
486		}
487
488	<	class SmallRunnable implements Runnable {
489	<	public void run() {
488	>	public abstract class CheckedInterruptedRunnable implements Runnable {
489	>	protected abstract void realRun() throws Throwable;
490	>
491	>	public final void run() {
492		try {
493	<	Thread.sleep(SMALL_DELAY_MS);
494	<	}
495	<	catch(Exception e) {
496	<	threadUnexpectedException(e);
493	>	realRun();
494	>	threadShouldThrow("InterruptedException");
495	>	} catch (InterruptedException success) {
496	>	} catch (Throwable t) {
497	>	threadUnexpectedException(t);
498		}
499		}
500		}
501
502	<	class SmallPossiblyInterruptedRunnable implements Runnable {
503	<	public void run() {
502	>	public abstract class CheckedCallable<T> implements Callable<T> {
503	>	protected abstract T realCall() throws Throwable;
504	>
505	>	public final T call() {
506		try {
507	<	Thread.sleep(SMALL_DELAY_MS);
508	<	}
509	<	catch(Exception e) {
507	>	return realCall();
508	>	} catch (Throwable t) {
509	>	threadUnexpectedException(t);
510		}
511	+	return null;
512		}
513		}
514
515	<	class SmallCallable implements Callable {
516	<	public Object call() {
515	>	public abstract class CheckedInterruptedCallable<T> implements Callable<T> {
516	>	protected abstract T realCall() throws Throwable;
517	>
518	>	public final T call() {
519		try {
520	<	Thread.sleep(SMALL_DELAY_MS);
520	>	T result = realCall();
521	>	threadShouldThrow("InterruptedException");
522	>	return result;
523	>	} catch (InterruptedException success) {
524	>	} catch (Throwable t) {
525	>	threadUnexpectedException(t);
526		}
527	<	catch(Exception e) {
468	<	threadUnexpectedException(e);
469	<	}
470	<	return Boolean.TRUE;
527	>	return null;
528		}
529		}
530
531	<	class SmallInterruptedRunnable implements Runnable {
532	<	public void run() {
531	>	public static class NoOpRunnable implements Runnable {
532	>	public void run() {}
533	>	}
534	>
535	>	public static class NoOpCallable implements Callable {
536	>	public Object call() { return Boolean.TRUE; }
537	>	}
538	>
539	>	public static final String TEST_STRING = "a test string";
540	>
541	>	public static class StringTask implements Callable<String> {
542	>	public String call() { return TEST_STRING; }
543	>	}
544	>
545	>	public static class NPETask implements Callable<String> {
546	>	public String call() { throw new NullPointerException(); }
547	>	}
548	>
549	>	public static class CallableOne implements Callable<Integer> {
550	>	public Integer call() { return one; }
551	>	}
552	>
553	>	public class ShortRunnable extends CheckedRunnable {
554	>	protected void realRun() throws Throwable {
555	>	Thread.sleep(SHORT_DELAY_MS);
556	>	}
557	>	}
558	>
559	>	public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
560	>	protected void realRun() throws InterruptedException {
561	>	Thread.sleep(SHORT_DELAY_MS);
562	>	}
563	>	}
564	>
565	>	public class SmallRunnable extends CheckedRunnable {
566	>	protected void realRun() throws Throwable {
567	>	Thread.sleep(SMALL_DELAY_MS);
568	>	}
569	>	}
570	>
571	>	public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
572	>	protected void realRun() {
573		try {
574		Thread.sleep(SMALL_DELAY_MS);
575	<	threadShouldThrow();
479	<	}
480	<	catch(InterruptedException success) {
481	<	}
575	>	} catch (InterruptedException ok) {}
576		}
577		}
578
579	+	public class SmallCallable extends CheckedCallable {
580	+	protected Object realCall() throws InterruptedException {
581	+	Thread.sleep(SMALL_DELAY_MS);
582	+	return Boolean.TRUE;
583	+	}
584	+	}
585
586	<	class MediumRunnable implements Runnable {
587	<	public void run() {
588	<	try {
489	<	Thread.sleep(MEDIUM_DELAY_MS);
490	<	}
491	<	catch(Exception e) {
492	<	threadUnexpectedException(e);
493	<	}
586	>	public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
587	>	protected void realRun() throws InterruptedException {
588	>	Thread.sleep(SMALL_DELAY_MS);
589		}
590		}
591
592	<	class MediumInterruptedRunnable implements Runnable {
593	<	public void run() {
594	<	try {
500	<	Thread.sleep(MEDIUM_DELAY_MS);
501	<	threadShouldThrow();
502	<	}
503	<	catch(InterruptedException success) {
504	<	}
592	>	public class MediumRunnable extends CheckedRunnable {
593	>	protected void realRun() throws Throwable {
594	>	Thread.sleep(MEDIUM_DELAY_MS);
595		}
596		}
597
598	<	class MediumPossiblyInterruptedRunnable implements Runnable {
599	<	public void run() {
598	>	public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
599	>	protected void realRun() throws InterruptedException {
600	>	Thread.sleep(MEDIUM_DELAY_MS);
601	>	}
602	>	}
603	>
604	>	public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
605	>	protected void realRun() {
606		try {
607		Thread.sleep(MEDIUM_DELAY_MS);
608	<	}
513	<	catch(InterruptedException success) {
514	<	}
608	>	} catch (InterruptedException ok) {}
609		}
610		}
611
612	<	class LongPossiblyInterruptedRunnable implements Runnable {
613	<	public void run() {
612	>	public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
613	>	protected void realRun() {
614		try {
615		Thread.sleep(LONG_DELAY_MS);
616	<	}
523	<	catch(InterruptedException success) {
524	<	}
616	>	} catch (InterruptedException ok) {}
617		}
618		}
619
620		/**
621		* For use as ThreadFactory in constructors
622		*/
623	<	static class SimpleThreadFactory implements ThreadFactory{
624	<	public Thread newThread(Runnable r){
623	>	public static class SimpleThreadFactory implements ThreadFactory {
624	>	public Thread newThread(Runnable r) {
625		return new Thread(r);
626		}
627		}
628
629	<	static class TrackedShortRunnable implements Runnable {
630	<	volatile boolean done = false;
629	>	public static class TrackedShortRunnable implements Runnable {
630	>	public volatile boolean done = false;
631		public void run() {
632		try {
633		Thread.sleep(SMALL_DELAY_MS);
634		done = true;
635	<	} catch(Exception e){
544	<	}
635	>	} catch (InterruptedException ok) {}
636		}
637		}
638
639	<	static class TrackedMediumRunnable implements Runnable {
640	<	volatile boolean done = false;
639	>	public static class TrackedMediumRunnable implements Runnable {
640	>	public volatile boolean done = false;
641		public void run() {
642		try {
643		Thread.sleep(MEDIUM_DELAY_MS);
644		done = true;
645	<	} catch(Exception e){
555	<	}
645	>	} catch (InterruptedException ok) {}
646		}
647		}
648
649	<	static class TrackedLongRunnable implements Runnable {
650	<	volatile boolean done = false;
649	>	public static class TrackedLongRunnable implements Runnable {
650	>	public volatile boolean done = false;
651		public void run() {
652		try {
653		Thread.sleep(LONG_DELAY_MS);
654		done = true;
655	<	} catch(Exception e){
566	<	}
655	>	} catch (InterruptedException ok) {}
656		}
657		}
658
659	<	static class TrackedNoOpRunnable implements Runnable {
660	<	volatile boolean done = false;
659	>	public static class TrackedNoOpRunnable implements Runnable {
660	>	public volatile boolean done = false;
661		public void run() {
662		done = true;
663		}
664		}
665
666	<	static class TrackedCallable implements Callable {
667	<	volatile boolean done = false;
666	>	public static class TrackedCallable implements Callable {
667	>	public volatile boolean done = false;
668		public Object call() {
669		try {
670		Thread.sleep(SMALL_DELAY_MS);
671		done = true;
672	<	} catch(Exception e){
584	<	}
672	>	} catch (InterruptedException ok) {}
673		return Boolean.TRUE;
674		}
675		}
#	Line 590 | Line 678 | public class JSR166TestCase extends Test
678		/**
679		* For use as RejectedExecutionHandler in constructors
680		*/
681	<	static class NoOpREHandler implements RejectedExecutionHandler{
682	<	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){}
681	>	public static class NoOpREHandler implements RejectedExecutionHandler {
682	>	public void rejectedExecution(Runnable r,
683	>	ThreadPoolExecutor executor) {}
684		}
685
597	–
686		}

Diff Legend

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