ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/JSR166TestCase.java
(Generate patch)

Comparing jsr166/src/test/tck/JSR166TestCase.java (file contents):
Revision 1.39 by jsr166, Tue Nov 17 21:51:45 2009 UTC vs.
Revision 1.48 by jsr166, Tue Dec 1 22:51:44 2009 UTC

# Line 90 | 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 106 | 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 195 | 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 294 | Line 294 | public class JSR166TestCase extends Test
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 +    /**
305       * threadFail with message "Unexpected exception"
306       */
307      public void threadUnexpectedException() {
# Line 320 | Line 328 | public class JSR166TestCase extends Test
328          } catch (SecurityException ok) {
329              // Allowed in case test doesn't have privs
330          } catch (InterruptedException ie) {
331 <            fail("Unexpected exception");
331 >            fail("Unexpected InterruptedException");
332          }
333      }
334  
# Line 333 | 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() {
# Line 351 | Line 366 | public class JSR166TestCase extends Test
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      /**
# Line 402 | Line 417 | public class JSR166TestCase extends Test
417      void sleepTillInterrupted(long timeoutMillis) {
418          try {
419              Thread.sleep(timeoutMillis);
420 <        } catch (InterruptedException wakeup) {
406 <        }
420 >        } catch (InterruptedException wakeup) {}
421      }
422  
423      /**
# Line 417 | Line 431 | public class JSR166TestCase extends Test
431  
432      // Some convenient Runnable classes
433  
434 <    abstract class CheckedRunnable implements Runnable {
435 <        abstract void realRun() throws Throwable;
434 >    public abstract class CheckedRunnable implements Runnable {
435 >        protected abstract void realRun() throws Throwable;
436  
437          public final void run() {
438              try {
# Line 429 | Line 443 | public class JSR166TestCase extends Test
443          }
444      }
445  
446 <    abstract class CheckedInterruptedRunnable implements Runnable {
447 <        abstract void realRun() throws Throwable;
446 >    public abstract class RunnableShouldThrow implements Runnable {
447 >        protected abstract void realRun() throws Throwable;
448 >
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 >                realRun();
458 >                threadShouldThrow(exceptionClass.getSimpleName());
459 >            } catch (Throwable t) {
460 >                if (! exceptionClass.isInstance(t))
461 >                    threadUnexpectedException(t);
462 >            }
463 >        }
464 >    }
465 >
466 >    public abstract class ThreadShouldThrow extends Thread {
467 >        protected abstract void realRun() throws Throwable;
468 >
469 >        final Class<?> exceptionClass;
470 >
471 >        <T extends Throwable> ThreadShouldThrow(Class<T> exceptionClass) {
472 >            this.exceptionClass = exceptionClass;
473 >        }
474  
475          public final void run() {
476              try {
477                  realRun();
478 <                threadShouldThrow();
478 >                threadShouldThrow(exceptionClass.getSimpleName());
479 >            } catch (Throwable t) {
480 >                if (! exceptionClass.isInstance(t))
481 >                    threadUnexpectedException(t);
482 >            }
483 >        }
484 >    }
485 >
486 >    public abstract class CheckedInterruptedRunnable implements Runnable {
487 >        protected abstract void realRun() throws Throwable;
488 >
489 >        public final void run() {
490 >            try {
491 >                realRun();
492 >                threadShouldThrow("InterruptedException");
493              } catch (InterruptedException success) {
494              } catch (Throwable t) {
495                  threadUnexpectedException(t);
# Line 443 | Line 497 | public class JSR166TestCase extends Test
497          }
498      }
499  
500 <    abstract class CheckedCallable<T> implements Callable<T> {
501 <        abstract T realCall() throws Throwable;
500 >    public abstract class CheckedCallable<T> implements Callable<T> {
501 >        protected abstract T realCall() throws Throwable;
502  
503          public final T call() {
504              try {
505                  return realCall();
506              } catch (Throwable t) {
507                  threadUnexpectedException(t);
454 –                return null;
508              }
509 +            return null;
510          }
511      }
512  
513 <    static class NoOpRunnable implements Runnable {
513 >    public abstract class CheckedInterruptedCallable<T> implements Callable<T> {
514 >        protected abstract T realCall() throws Throwable;
515 >
516 >        public final T call() {
517 >            try {
518 >                T result = realCall();
519 >                threadShouldThrow("InterruptedException");
520 >                return result;
521 >            } catch (InterruptedException success) {
522 >            } catch (Throwable t) {
523 >                threadUnexpectedException(t);
524 >            }
525 >            return null;
526 >        }
527 >    }
528 >
529 >    public static class NoOpRunnable implements Runnable {
530          public void run() {}
531      }
532  
533 <    static class NoOpCallable implements Callable {
533 >    public static class NoOpCallable implements Callable {
534          public Object call() { return Boolean.TRUE; }
535      }
536  
537 <    static final String TEST_STRING = "a test string";
537 >    public static final String TEST_STRING = "a test string";
538  
539 <    static class StringTask implements Callable<String> {
539 >    public static class StringTask implements Callable<String> {
540          public String call() { return TEST_STRING; }
541      }
542  
543 <    static class NPETask implements Callable<String> {
543 >    public Callable<String> latchAwaitingStringTask(final CountDownLatch latch) {
544 >        return new CheckedCallable<String>() {
545 >            public String realCall() {
546 >                try {
547 >                    latch.await();
548 >                } catch (InterruptedException quittingTime) {}
549 >                return TEST_STRING;
550 >            }};
551 >    }
552 >
553 >    public static class NPETask implements Callable<String> {
554          public String call() { throw new NullPointerException(); }
555      }
556  
557 <    static class CallableOne implements Callable<Integer> {
557 >    public static class CallableOne implements Callable<Integer> {
558          public Integer call() { return one; }
559      }
560  
561 <    class ShortRunnable extends CheckedRunnable {
562 <        void realRun() throws Throwable {
561 >    public class ShortRunnable extends CheckedRunnable {
562 >        protected void realRun() throws Throwable {
563              Thread.sleep(SHORT_DELAY_MS);
564          }
565      }
566  
567 <    class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
568 <        void realRun() throws InterruptedException {
567 >    public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
568 >        protected void realRun() throws InterruptedException {
569              Thread.sleep(SHORT_DELAY_MS);
570          }
571      }
572  
573 <    class SmallRunnable extends CheckedRunnable {
574 <        void realRun() throws Throwable {
573 >    public class SmallRunnable extends CheckedRunnable {
574 >        protected void realRun() throws Throwable {
575              Thread.sleep(SMALL_DELAY_MS);
576          }
577      }
578  
579 <    class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
580 <        void realRun() {
579 >    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
580 >        protected void realRun() {
581              try {
582                  Thread.sleep(SMALL_DELAY_MS);
583 <            }
504 <            catch (InterruptedException ok) {
505 <            }
583 >            } catch (InterruptedException ok) {}
584          }
585      }
586  
587 <    class SmallCallable extends CheckedCallable {
588 <        Object realCall() throws Throwable {
587 >    public class SmallCallable extends CheckedCallable {
588 >        protected Object realCall() throws InterruptedException {
589              Thread.sleep(SMALL_DELAY_MS);
590              return Boolean.TRUE;
591          }
592      }
593  
594 <    class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
595 <        void realRun() throws InterruptedException {
594 >    public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
595 >        protected void realRun() throws InterruptedException {
596              Thread.sleep(SMALL_DELAY_MS);
597          }
598      }
599  
600 <    class MediumRunnable extends CheckedRunnable {
601 <        void realRun() throws Throwable {
600 >    public class MediumRunnable extends CheckedRunnable {
601 >        protected void realRun() throws Throwable {
602              Thread.sleep(MEDIUM_DELAY_MS);
603          }
604      }
605  
606 <    class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
607 <        void realRun() throws InterruptedException {
606 >    public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
607 >        protected void realRun() throws InterruptedException {
608              Thread.sleep(MEDIUM_DELAY_MS);
609          }
610      }
611  
612 <    class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
613 <        void realRun() {
612 >    public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
613 >        protected void realRun() {
614              try {
615                  Thread.sleep(MEDIUM_DELAY_MS);
616 <            }
539 <            catch (InterruptedException ok) {
540 <            }
616 >            } catch (InterruptedException ok) {}
617          }
618      }
619  
620 <    class LongPossiblyInterruptedRunnable extends CheckedRunnable {
621 <        void realRun() {
620 >    public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
621 >        protected void realRun() {
622              try {
623                  Thread.sleep(LONG_DELAY_MS);
624 <            }
549 <            catch (InterruptedException ok) {
550 <            }
624 >            } catch (InterruptedException ok) {}
625          }
626      }
627  
628      /**
629       * For use as ThreadFactory in constructors
630       */
631 <    static class SimpleThreadFactory implements ThreadFactory {
631 >    public static class SimpleThreadFactory implements ThreadFactory {
632          public Thread newThread(Runnable r) {
633              return new Thread(r);
634          }
635      }
636  
637 <    static class TrackedShortRunnable implements Runnable {
638 <        volatile boolean done = false;
637 >    public static class TrackedShortRunnable implements Runnable {
638 >        public volatile boolean done = false;
639          public void run() {
640              try {
641                  Thread.sleep(SMALL_DELAY_MS);
642                  done = true;
643 <            } catch (InterruptedException ok) {
570 <            }
643 >            } catch (InterruptedException ok) {}
644          }
645      }
646  
647 <    static class TrackedMediumRunnable implements Runnable {
648 <        volatile boolean done = false;
647 >    public static class TrackedMediumRunnable implements Runnable {
648 >        public volatile boolean done = false;
649          public void run() {
650              try {
651                  Thread.sleep(MEDIUM_DELAY_MS);
652                  done = true;
653 <            } catch (InterruptedException ok) {
581 <            }
653 >            } catch (InterruptedException ok) {}
654          }
655      }
656  
657 <    static class TrackedLongRunnable implements Runnable {
658 <        volatile boolean done = false;
657 >    public static class TrackedLongRunnable implements Runnable {
658 >        public volatile boolean done = false;
659          public void run() {
660              try {
661                  Thread.sleep(LONG_DELAY_MS);
662                  done = true;
663 <            } catch (InterruptedException ok) {
592 <            }
663 >            } catch (InterruptedException ok) {}
664          }
665      }
666  
667 <    static class TrackedNoOpRunnable implements Runnable {
668 <        volatile boolean done = false;
667 >    public static class TrackedNoOpRunnable implements Runnable {
668 >        public volatile boolean done = false;
669          public void run() {
670              done = true;
671          }
672      }
673  
674 <    static class TrackedCallable implements Callable {
675 <        volatile boolean done = false;
674 >    public static class TrackedCallable implements Callable {
675 >        public volatile boolean done = false;
676          public Object call() {
677              try {
678                  Thread.sleep(SMALL_DELAY_MS);
679                  done = true;
680 <            } catch (InterruptedException ok) {
610 <            }
680 >            } catch (InterruptedException ok) {}
681              return Boolean.TRUE;
682          }
683      }
# Line 616 | Line 686 | public class JSR166TestCase extends Test
686      /**
687       * For use as RejectedExecutionHandler in constructors
688       */
689 <    static class NoOpREHandler implements RejectedExecutionHandler {
689 >    public static class NoOpREHandler implements RejectedExecutionHandler {
690          public void rejectedExecution(Runnable r,
691                                        ThreadPoolExecutor executor) {}
692      }

Diff Legend

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