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.59 by jsr166, Wed Oct 6 02:58:04 2010 UTC vs.
Revision 1.73 by jsr166, Mon Nov 29 07:39:53 2010 UTC

# Line 7 | Line 7
7   */
8  
9   import junit.framework.*;
10 + import java.util.Arrays;
11 + import java.util.NoSuchElementException;
12   import java.util.PropertyPermission;
13   import java.util.concurrent.*;
14   import java.util.concurrent.atomic.AtomicReference;
15   import static java.util.concurrent.TimeUnit.MILLISECONDS;
16 + import static java.util.concurrent.TimeUnit.NANOSECONDS;
17   import java.security.CodeSource;
18   import java.security.Permission;
19   import java.security.PermissionCollection;
# Line 96 | Line 99 | public class JSR166TestCase extends Test
99      private static final boolean useSecurityManager =
100          Boolean.getBoolean("jsr166.useSecurityManager");
101  
102 +    protected static final boolean expensiveTests =
103 +        Boolean.getBoolean("jsr166.expensiveTests");
104 +
105 +    /**
106 +     * If true, report on stdout all "slow" tests, that is, ones that
107 +     * take more than profileThreshold milliseconds to execute.
108 +     */
109 +    private static final boolean profileTests =
110 +        Boolean.getBoolean("jsr166.profileTests");
111 +
112 +    /**
113 +     * The number of milliseconds that tests are permitted for
114 +     * execution without being reported, when profileTests is set.
115 +     */
116 +    private static final long profileThreshold =
117 +        Long.getLong("jsr166.profileThreshold", 100);
118 +
119 +    protected void runTest() throws Throwable {
120 +        if (profileTests)
121 +            runTestProfiled();
122 +        else
123 +            super.runTest();
124 +    }
125 +
126 +    protected void runTestProfiled() throws Throwable {
127 +        long t0 = System.nanoTime();
128 +        try {
129 +            super.runTest();
130 +        } finally {
131 +            long elapsedMillis =
132 +                (System.nanoTime() - t0) / (1000L * 1000L);
133 +            if (elapsedMillis >= profileThreshold)
134 +                System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
135 +        }
136 +    }
137 +
138      /**
139       * Runs all JSR166 unit tests using junit.textui.TestRunner
140       */
# Line 116 | Line 155 | public class JSR166TestCase extends Test
155          System.exit(0);
156      }
157  
158 +    public static TestSuite newTestSuite(Object... suiteOrClasses) {
159 +        TestSuite suite = new TestSuite();
160 +        for (Object suiteOrClass : suiteOrClasses) {
161 +            if (suiteOrClass instanceof TestSuite)
162 +                suite.addTest((TestSuite) suiteOrClass);
163 +            else if (suiteOrClass instanceof Class)
164 +                suite.addTest(new TestSuite((Class<?>) suiteOrClass));
165 +            else
166 +                throw new ClassCastException("not a test suite or class");
167 +        }
168 +        return suite;
169 +    }
170 +
171      /**
172 <     * Collects all JSR166 unit tests as one suite
172 >     * Collects all JSR166 unit tests as one suite.
173       */
174      public static Test suite() {
175 <        TestSuite suite = new TestSuite("JSR166 Unit Tests");
176 <
177 <        suite.addTest(ForkJoinPoolTest.suite());
178 <        suite.addTest(ForkJoinTaskTest.suite());
179 <        suite.addTest(RecursiveActionTest.suite());
180 <        suite.addTest(RecursiveTaskTest.suite());
181 <        suite.addTest(LinkedTransferQueueTest.suite());
182 <        suite.addTest(PhaserTest.suite());
183 <        suite.addTest(ThreadLocalRandomTest.suite());
184 <        suite.addTest(AbstractExecutorServiceTest.suite());
185 <        suite.addTest(AbstractQueueTest.suite());
186 <        suite.addTest(AbstractQueuedSynchronizerTest.suite());
187 <        suite.addTest(AbstractQueuedLongSynchronizerTest.suite());
188 <        suite.addTest(ArrayBlockingQueueTest.suite());
189 <        suite.addTest(ArrayDequeTest.suite());
190 <        suite.addTest(AtomicBooleanTest.suite());
191 <        suite.addTest(AtomicIntegerArrayTest.suite());
192 <        suite.addTest(AtomicIntegerFieldUpdaterTest.suite());
193 <        suite.addTest(AtomicIntegerTest.suite());
194 <        suite.addTest(AtomicLongArrayTest.suite());
195 <        suite.addTest(AtomicLongFieldUpdaterTest.suite());
196 <        suite.addTest(AtomicLongTest.suite());
197 <        suite.addTest(AtomicMarkableReferenceTest.suite());
198 <        suite.addTest(AtomicReferenceArrayTest.suite());
199 <        suite.addTest(AtomicReferenceFieldUpdaterTest.suite());
200 <        suite.addTest(AtomicReferenceTest.suite());
201 <        suite.addTest(AtomicStampedReferenceTest.suite());
202 <        suite.addTest(ConcurrentHashMapTest.suite());
203 <        suite.addTest(ConcurrentLinkedDequeTest.suite());
204 <        suite.addTest(ConcurrentLinkedQueueTest.suite());
205 <        suite.addTest(ConcurrentSkipListMapTest.suite());
206 <        suite.addTest(ConcurrentSkipListSubMapTest.suite());
207 <        suite.addTest(ConcurrentSkipListSetTest.suite());
208 <        suite.addTest(ConcurrentSkipListSubSetTest.suite());
209 <        suite.addTest(CopyOnWriteArrayListTest.suite());
210 <        suite.addTest(CopyOnWriteArraySetTest.suite());
211 <        suite.addTest(CountDownLatchTest.suite());
212 <        suite.addTest(CyclicBarrierTest.suite());
213 <        suite.addTest(DelayQueueTest.suite());
214 <        suite.addTest(EntryTest.suite());
215 <        suite.addTest(ExchangerTest.suite());
216 <        suite.addTest(ExecutorsTest.suite());
217 <        suite.addTest(ExecutorCompletionServiceTest.suite());
218 <        suite.addTest(FutureTaskTest.suite());
219 <        suite.addTest(LinkedBlockingDequeTest.suite());
220 <        suite.addTest(LinkedBlockingQueueTest.suite());
221 <        suite.addTest(LinkedListTest.suite());
222 <        suite.addTest(LockSupportTest.suite());
223 <        suite.addTest(PriorityBlockingQueueTest.suite());
224 <        suite.addTest(PriorityQueueTest.suite());
225 <        suite.addTest(ReentrantLockTest.suite());
226 <        suite.addTest(ReentrantReadWriteLockTest.suite());
227 <        suite.addTest(ScheduledExecutorTest.suite());
228 <        suite.addTest(ScheduledExecutorSubclassTest.suite());
229 <        suite.addTest(SemaphoreTest.suite());
230 <        suite.addTest(SynchronousQueueTest.suite());
231 <        suite.addTest(SystemTest.suite());
232 <        suite.addTest(ThreadLocalTest.suite());
233 <        suite.addTest(ThreadPoolExecutorTest.suite());
234 <        suite.addTest(ThreadPoolExecutorSubclassTest.suite());
235 <        suite.addTest(ThreadTest.suite());
236 <        suite.addTest(TimeUnitTest.suite());
237 <        suite.addTest(TreeMapTest.suite());
238 <        suite.addTest(TreeSetTest.suite());
239 <        suite.addTest(TreeSubMapTest.suite());
188 <        suite.addTest(TreeSubSetTest.suite());
189 <
190 <        return suite;
175 >        return newTestSuite(
176 >            ForkJoinPoolTest.suite(),
177 >            ForkJoinTaskTest.suite(),
178 >            RecursiveActionTest.suite(),
179 >            RecursiveTaskTest.suite(),
180 >            LinkedTransferQueueTest.suite(),
181 >            PhaserTest.suite(),
182 >            ThreadLocalRandomTest.suite(),
183 >            AbstractExecutorServiceTest.suite(),
184 >            AbstractQueueTest.suite(),
185 >            AbstractQueuedSynchronizerTest.suite(),
186 >            AbstractQueuedLongSynchronizerTest.suite(),
187 >            ArrayBlockingQueueTest.suite(),
188 >            ArrayDequeTest.suite(),
189 >            AtomicBooleanTest.suite(),
190 >            AtomicIntegerArrayTest.suite(),
191 >            AtomicIntegerFieldUpdaterTest.suite(),
192 >            AtomicIntegerTest.suite(),
193 >            AtomicLongArrayTest.suite(),
194 >            AtomicLongFieldUpdaterTest.suite(),
195 >            AtomicLongTest.suite(),
196 >            AtomicMarkableReferenceTest.suite(),
197 >            AtomicReferenceArrayTest.suite(),
198 >            AtomicReferenceFieldUpdaterTest.suite(),
199 >            AtomicReferenceTest.suite(),
200 >            AtomicStampedReferenceTest.suite(),
201 >            ConcurrentHashMapTest.suite(),
202 >            ConcurrentLinkedDequeTest.suite(),
203 >            ConcurrentLinkedQueueTest.suite(),
204 >            ConcurrentSkipListMapTest.suite(),
205 >            ConcurrentSkipListSubMapTest.suite(),
206 >            ConcurrentSkipListSetTest.suite(),
207 >            ConcurrentSkipListSubSetTest.suite(),
208 >            CopyOnWriteArrayListTest.suite(),
209 >            CopyOnWriteArraySetTest.suite(),
210 >            CountDownLatchTest.suite(),
211 >            CyclicBarrierTest.suite(),
212 >            DelayQueueTest.suite(),
213 >            EntryTest.suite(),
214 >            ExchangerTest.suite(),
215 >            ExecutorsTest.suite(),
216 >            ExecutorCompletionServiceTest.suite(),
217 >            FutureTaskTest.suite(),
218 >            LinkedBlockingDequeTest.suite(),
219 >            LinkedBlockingQueueTest.suite(),
220 >            LinkedListTest.suite(),
221 >            LockSupportTest.suite(),
222 >            PriorityBlockingQueueTest.suite(),
223 >            PriorityQueueTest.suite(),
224 >            ReentrantLockTest.suite(),
225 >            ReentrantReadWriteLockTest.suite(),
226 >            ScheduledExecutorTest.suite(),
227 >            ScheduledExecutorSubclassTest.suite(),
228 >            SemaphoreTest.suite(),
229 >            SynchronousQueueTest.suite(),
230 >            SystemTest.suite(),
231 >            ThreadLocalTest.suite(),
232 >            ThreadPoolExecutorTest.suite(),
233 >            ThreadPoolExecutorSubclassTest.suite(),
234 >            ThreadTest.suite(),
235 >            TimeUnitTest.suite(),
236 >            TreeMapTest.suite(),
237 >            TreeSetTest.suite(),
238 >            TreeSubMapTest.suite(),
239 >            TreeSubSetTest.suite());
240      }
241  
242  
# Line 213 | Line 262 | public class JSR166TestCase extends Test
262          SHORT_DELAY_MS = getShortDelay();
263          SMALL_DELAY_MS  = SHORT_DELAY_MS * 5;
264          MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10;
265 <        LONG_DELAY_MS   = SHORT_DELAY_MS * 50;
265 >        LONG_DELAY_MS   = SHORT_DELAY_MS * 200;
266      }
267  
268      /**
# Line 242 | Line 291 | public class JSR166TestCase extends Test
291       * earlier by threadRecordFailure.
292       */
293      public void tearDown() throws Exception {
294 <        Throwable t = threadFailure.get();
294 >        Throwable t = threadFailure.getAndSet(null);
295          if (t != null) {
296              if (t instanceof Error)
297                  throw (Error) t;
# Line 400 | Line 449 | public class JSR166TestCase extends Test
449          try {
450              exec.shutdown();
451              assertTrue("ExecutorService did not terminate in a timely manner",
452 <                       exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
452 >                       exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS));
453          } catch (SecurityException ok) {
454              // Allowed in case test doesn't have privs
455          } catch (InterruptedException ie) {
# Line 534 | Line 583 | public class JSR166TestCase extends Test
583      }
584  
585      /**
586 +     * Sleeps until the given time has elapsed.
587 +     * Throws AssertionFailedError if interrupted.
588 +     */
589 +    void sleep(long millis) {
590 +        try {
591 +            Thread.sleep(millis);
592 +        } catch (InterruptedException ie) {
593 +            AssertionFailedError afe =
594 +                new AssertionFailedError("Unexpected InterruptedException");
595 +            afe.initCause(ie);
596 +            throw afe;
597 +        }
598 +    }
599 +
600 +    /**
601       * Sleeps until the timeout has elapsed, or interrupted.
602       * Does <em>NOT</em> throw InterruptedException.
603       */
# Line 544 | Line 608 | public class JSR166TestCase extends Test
608      }
609  
610      /**
611 +     * Waits up to the specified number of milliseconds for the given
612 +     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
613 +     */
614 +    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
615 +        long timeoutNanos = timeoutMillis * 1000L * 1000L;
616 +        long t0 = System.nanoTime();
617 +        for (;;) {
618 +            Thread.State s = thread.getState();
619 +            if (s == Thread.State.BLOCKED ||
620 +                s == Thread.State.WAITING ||
621 +                s == Thread.State.TIMED_WAITING)
622 +                return;
623 +            else if (s == Thread.State.TERMINATED)
624 +                fail("Unexpected thread termination");
625 +            else if (System.nanoTime() - t0 > timeoutNanos) {
626 +                threadAssertTrue(thread.isAlive());
627 +                return;
628 +            }
629 +            Thread.yield();
630 +        }
631 +    }
632 +
633 +    /**
634 +     * Returns the number of milliseconds since time given by
635 +     * startNanoTime, which must have been previously returned from a
636 +     * call to {@link System.nanoTime()}.
637 +     */
638 +    long millisElapsedSince(long startNanoTime) {
639 +        return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
640 +    }
641 +
642 +    /**
643       * Returns a new started daemon Thread running the given runnable.
644       */
645      Thread newStartedThread(Runnable runnable) {
# Line 685 | Line 781 | public class JSR166TestCase extends Test
781  
782      public Callable<String> latchAwaitingStringTask(final CountDownLatch latch) {
783          return new CheckedCallable<String>() {
784 <            public String realCall() {
784 >            protected String realCall() {
785                  try {
786                      latch.await();
787                  } catch (InterruptedException quittingTime) {}
# Line 693 | Line 789 | public class JSR166TestCase extends Test
789              }};
790      }
791  
792 +    public Runnable awaiter(final CountDownLatch latch) {
793 +        return new CheckedRunnable() {
794 +            public void realRun() throws InterruptedException {
795 +                latch.await();
796 +            }};
797 +    }
798 +
799      public static class NPETask implements Callable<String> {
800          public String call() { throw new NullPointerException(); }
801      }
# Line 746 | Line 849 | public class JSR166TestCase extends Test
849          }
850      }
851  
852 +    public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
853 +        return new CheckedRunnable() {
854 +            protected void realRun() {
855 +                try {
856 +                    Thread.sleep(timeoutMillis);
857 +                } catch (InterruptedException ok) {}
858 +            }};
859 +    }
860 +
861      public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
862          protected void realRun() {
863              try {
# Line 771 | Line 883 | public class JSR166TestCase extends Test
883          }
884      }
885  
886 +    public interface TrackedRunnable extends Runnable {
887 +        boolean isDone();
888 +    }
889 +
890 +    public static TrackedRunnable trackedRunnable(final long timeoutMillis) {
891 +        return new TrackedRunnable() {
892 +                private volatile boolean done = false;
893 +                public boolean isDone() { return done; }
894 +                public void run() {
895 +                    try {
896 +                        Thread.sleep(timeoutMillis);
897 +                        done = true;
898 +                    } catch (InterruptedException ok) {}
899 +                }
900 +            };
901 +    }
902 +
903      public static class TrackedShortRunnable implements Runnable {
904          public volatile boolean done = false;
905          public void run() {
906              try {
907 +                Thread.sleep(SHORT_DELAY_MS);
908 +                done = true;
909 +            } catch (InterruptedException ok) {}
910 +        }
911 +    }
912 +
913 +    public static class TrackedSmallRunnable implements Runnable {
914 +        public volatile boolean done = false;
915 +        public void run() {
916 +            try {
917                  Thread.sleep(SMALL_DELAY_MS);
918                  done = true;
919              } catch (InterruptedException ok) {}
# Line 858 | Line 997 | public class JSR166TestCase extends Test
997                                        ThreadPoolExecutor executor) {}
998      }
999  
1000 +    /**
1001 +     * A CyclicBarrier that fails with AssertionFailedErrors instead
1002 +     * of throwing checked exceptions.
1003 +     */
1004 +    public class CheckedBarrier extends CyclicBarrier {
1005 +        public CheckedBarrier(int parties) { super(parties); }
1006 +
1007 +        public int await() {
1008 +            try {
1009 +                return super.await();
1010 +            } catch (Exception e) {
1011 +                AssertionFailedError afe =
1012 +                    new AssertionFailedError("Unexpected exception: " + e);
1013 +                afe.initCause(e);
1014 +                throw afe;
1015 +            }
1016 +        }
1017 +    }
1018 +
1019 +    public void checkEmpty(BlockingQueue q) {
1020 +        try {
1021 +            assertTrue(q.isEmpty());
1022 +            assertEquals(0, q.size());
1023 +            assertNull(q.peek());
1024 +            assertNull(q.poll());
1025 +            assertNull(q.poll(0, MILLISECONDS));
1026 +            assertEquals(q.toString(), "[]");
1027 +            assertTrue(Arrays.equals(q.toArray(), new Object[0]));
1028 +            assertFalse(q.iterator().hasNext());
1029 +            try {
1030 +                q.element();
1031 +                shouldThrow();
1032 +            } catch (NoSuchElementException success) {}
1033 +            try {
1034 +                q.iterator().next();
1035 +                shouldThrow();
1036 +            } catch (NoSuchElementException success) {}
1037 +            try {
1038 +                q.remove();
1039 +                shouldThrow();
1040 +            } catch (NoSuchElementException success) {}
1041 +        } catch (InterruptedException ie) {
1042 +            threadUnexpectedException(ie);
1043 +        }
1044 +    }
1045 +
1046   }

Diff Legend

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