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.56 by jsr166, Sun Oct 3 23:59:05 2010 UTC vs.
Revision 1.60 by jsr166, Wed Oct 6 07:49:22 2010 UTC

# Line 116 | Line 116 | public class JSR166TestCase extends Test
116          System.exit(0);
117      }
118  
119 +    public static TestSuite newTestSuite(Object... suiteOrClasses) {
120 +        TestSuite suite = new TestSuite();
121 +        for (Object suiteOrClass : suiteOrClasses) {
122 +            if (suiteOrClass instanceof TestSuite)
123 +                suite.addTest((TestSuite) suiteOrClass);
124 +            else if (suiteOrClass instanceof Class)
125 +                suite.addTest(new TestSuite((Class<?>) suiteOrClass));
126 +            else
127 +                throw new ClassCastException("not a test suite or class");
128 +        }
129 +        return suite;
130 +    }
131 +
132      /**
133 <     * Collects all JSR166 unit tests as one suite
133 >     * Collects all JSR166 unit tests as one suite.
134       */
135      public static Test suite() {
136 <        TestSuite suite = new TestSuite("JSR166 Unit Tests");
137 <
138 <        suite.addTest(ForkJoinPoolTest.suite());
139 <        suite.addTest(ForkJoinTaskTest.suite());
140 <        suite.addTest(RecursiveActionTest.suite());
141 <        suite.addTest(RecursiveTaskTest.suite());
142 <        suite.addTest(LinkedTransferQueueTest.suite());
143 <        suite.addTest(PhaserTest.suite());
144 <        suite.addTest(ThreadLocalRandomTest.suite());
145 <        suite.addTest(AbstractExecutorServiceTest.suite());
146 <        suite.addTest(AbstractQueueTest.suite());
147 <        suite.addTest(AbstractQueuedSynchronizerTest.suite());
148 <        suite.addTest(AbstractQueuedLongSynchronizerTest.suite());
149 <        suite.addTest(ArrayBlockingQueueTest.suite());
150 <        suite.addTest(ArrayDequeTest.suite());
151 <        suite.addTest(AtomicBooleanTest.suite());
152 <        suite.addTest(AtomicIntegerArrayTest.suite());
153 <        suite.addTest(AtomicIntegerFieldUpdaterTest.suite());
154 <        suite.addTest(AtomicIntegerTest.suite());
155 <        suite.addTest(AtomicLongArrayTest.suite());
156 <        suite.addTest(AtomicLongFieldUpdaterTest.suite());
157 <        suite.addTest(AtomicLongTest.suite());
158 <        suite.addTest(AtomicMarkableReferenceTest.suite());
159 <        suite.addTest(AtomicReferenceArrayTest.suite());
160 <        suite.addTest(AtomicReferenceFieldUpdaterTest.suite());
161 <        suite.addTest(AtomicReferenceTest.suite());
162 <        suite.addTest(AtomicStampedReferenceTest.suite());
163 <        suite.addTest(ConcurrentHashMapTest.suite());
164 <        suite.addTest(ConcurrentLinkedDequeTest.suite());
165 <        suite.addTest(ConcurrentLinkedQueueTest.suite());
166 <        suite.addTest(ConcurrentSkipListMapTest.suite());
167 <        suite.addTest(ConcurrentSkipListSubMapTest.suite());
168 <        suite.addTest(ConcurrentSkipListSetTest.suite());
169 <        suite.addTest(ConcurrentSkipListSubSetTest.suite());
170 <        suite.addTest(CopyOnWriteArrayListTest.suite());
171 <        suite.addTest(CopyOnWriteArraySetTest.suite());
172 <        suite.addTest(CountDownLatchTest.suite());
173 <        suite.addTest(CyclicBarrierTest.suite());
174 <        suite.addTest(DelayQueueTest.suite());
175 <        suite.addTest(EntryTest.suite());
176 <        suite.addTest(ExchangerTest.suite());
177 <        suite.addTest(ExecutorsTest.suite());
178 <        suite.addTest(ExecutorCompletionServiceTest.suite());
179 <        suite.addTest(FutureTaskTest.suite());
180 <        suite.addTest(LinkedBlockingDequeTest.suite());
181 <        suite.addTest(LinkedBlockingQueueTest.suite());
182 <        suite.addTest(LinkedListTest.suite());
183 <        suite.addTest(LockSupportTest.suite());
184 <        suite.addTest(PriorityBlockingQueueTest.suite());
185 <        suite.addTest(PriorityQueueTest.suite());
186 <        suite.addTest(ReentrantLockTest.suite());
187 <        suite.addTest(ReentrantReadWriteLockTest.suite());
188 <        suite.addTest(ScheduledExecutorTest.suite());
189 <        suite.addTest(ScheduledExecutorSubclassTest.suite());
190 <        suite.addTest(SemaphoreTest.suite());
191 <        suite.addTest(SynchronousQueueTest.suite());
192 <        suite.addTest(SystemTest.suite());
193 <        suite.addTest(ThreadLocalTest.suite());
194 <        suite.addTest(ThreadPoolExecutorTest.suite());
195 <        suite.addTest(ThreadPoolExecutorSubclassTest.suite());
196 <        suite.addTest(ThreadTest.suite());
197 <        suite.addTest(TimeUnitTest.suite());
198 <        suite.addTest(TreeMapTest.suite());
199 <        suite.addTest(TreeSetTest.suite());
200 <        suite.addTest(TreeSubMapTest.suite());
188 <        suite.addTest(TreeSubSetTest.suite());
189 <
190 <        return suite;
136 >        return newTestSuite(
137 >            ForkJoinPoolTest.suite(),
138 >            ForkJoinTaskTest.suite(),
139 >            RecursiveActionTest.suite(),
140 >            RecursiveTaskTest.suite(),
141 >            LinkedTransferQueueTest.suite(),
142 >            PhaserTest.suite(),
143 >            ThreadLocalRandomTest.suite(),
144 >            AbstractExecutorServiceTest.suite(),
145 >            AbstractQueueTest.suite(),
146 >            AbstractQueuedSynchronizerTest.suite(),
147 >            AbstractQueuedLongSynchronizerTest.suite(),
148 >            ArrayBlockingQueueTest.suite(),
149 >            ArrayDequeTest.suite(),
150 >            AtomicBooleanTest.suite(),
151 >            AtomicIntegerArrayTest.suite(),
152 >            AtomicIntegerFieldUpdaterTest.suite(),
153 >            AtomicIntegerTest.suite(),
154 >            AtomicLongArrayTest.suite(),
155 >            AtomicLongFieldUpdaterTest.suite(),
156 >            AtomicLongTest.suite(),
157 >            AtomicMarkableReferenceTest.suite(),
158 >            AtomicReferenceArrayTest.suite(),
159 >            AtomicReferenceFieldUpdaterTest.suite(),
160 >            AtomicReferenceTest.suite(),
161 >            AtomicStampedReferenceTest.suite(),
162 >            ConcurrentHashMapTest.suite(),
163 >            ConcurrentLinkedDequeTest.suite(),
164 >            ConcurrentLinkedQueueTest.suite(),
165 >            ConcurrentSkipListMapTest.suite(),
166 >            ConcurrentSkipListSubMapTest.suite(),
167 >            ConcurrentSkipListSetTest.suite(),
168 >            ConcurrentSkipListSubSetTest.suite(),
169 >            CopyOnWriteArrayListTest.suite(),
170 >            CopyOnWriteArraySetTest.suite(),
171 >            CountDownLatchTest.suite(),
172 >            CyclicBarrierTest.suite(),
173 >            DelayQueueTest.suite(),
174 >            EntryTest.suite(),
175 >            ExchangerTest.suite(),
176 >            ExecutorsTest.suite(),
177 >            ExecutorCompletionServiceTest.suite(),
178 >            FutureTaskTest.suite(),
179 >            LinkedBlockingDequeTest.suite(),
180 >            LinkedBlockingQueueTest.suite(),
181 >            LinkedListTest.suite(),
182 >            LockSupportTest.suite(),
183 >            PriorityBlockingQueueTest.suite(),
184 >            PriorityQueueTest.suite(),
185 >            ReentrantLockTest.suite(),
186 >            ReentrantReadWriteLockTest.suite(),
187 >            ScheduledExecutorTest.suite(),
188 >            ScheduledExecutorSubclassTest.suite(),
189 >            SemaphoreTest.suite(),
190 >            SynchronousQueueTest.suite(),
191 >            SystemTest.suite(),
192 >            ThreadLocalTest.suite(),
193 >            ThreadPoolExecutorTest.suite(),
194 >            ThreadPoolExecutorSubclassTest.suite(),
195 >            ThreadTest.suite(),
196 >            TimeUnitTest.suite(),
197 >            TreeMapTest.suite(),
198 >            TreeSetTest.suite(),
199 >            TreeSubMapTest.suite(),
200 >            TreeSubSetTest.suite());
201      }
202  
203  
# Line 250 | Line 260 | public class JSR166TestCase extends Test
260                  throw (RuntimeException) t;
261              else if (t instanceof Exception)
262                  throw (Exception) t;
263 <            else
264 <                throw new AssertionError(t);
263 >            else {
264 >                AssertionFailedError afe =
265 >                    new AssertionFailedError(t.toString());
266 >                afe.initCause(t);
267 >                throw afe;
268 >            }
269          }
270      }
271  
272      /**
273       * Just like fail(reason), but additionally recording (using
274 <     * threadRecordFailure) any AssertionError thrown, so that the current
275 <     * testcase will fail.
274 >     * threadRecordFailure) any AssertionFailedError thrown, so that
275 >     * the current testcase will fail.
276       */
277      public void threadFail(String reason) {
278          try {
279              fail(reason);
280 <        } catch (Throwable t) {
280 >        } catch (AssertionFailedError t) {
281              threadRecordFailure(t);
282              fail(reason);
283          }
# Line 271 | Line 285 | public class JSR166TestCase extends Test
285  
286      /**
287       * Just like assertTrue(b), but additionally recording (using
288 <     * threadRecordFailure) any AssertionError thrown, so that the current
289 <     * testcase will fail.
288 >     * threadRecordFailure) any AssertionFailedError thrown, so that
289 >     * the current testcase will fail.
290       */
291      public void threadAssertTrue(boolean b) {
292          try {
293              assertTrue(b);
294 <        } catch (AssertionError t) {
294 >        } catch (AssertionFailedError t) {
295              threadRecordFailure(t);
296              throw t;
297          }
# Line 285 | Line 299 | public class JSR166TestCase extends Test
299  
300      /**
301       * Just like assertFalse(b), but additionally recording (using
302 <     * threadRecordFailure) any AssertionError thrown, so that the
303 <     * current testcase will fail.
302 >     * threadRecordFailure) any AssertionFailedError thrown, so that
303 >     * the current testcase will fail.
304       */
305      public void threadAssertFalse(boolean b) {
306          try {
307              assertFalse(b);
308 <        } catch (AssertionError t) {
308 >        } catch (AssertionFailedError t) {
309              threadRecordFailure(t);
310              throw t;
311          }
# Line 299 | Line 313 | public class JSR166TestCase extends Test
313  
314      /**
315       * Just like assertNull(x), but additionally recording (using
316 <     * threadRecordFailure) any AssertionError thrown, so that the
317 <     * current testcase will fail.
316 >     * threadRecordFailure) any AssertionFailedError thrown, so that
317 >     * the current testcase will fail.
318       */
319      public void threadAssertNull(Object x) {
320          try {
321              assertNull(x);
322 <        } catch (AssertionError t) {
322 >        } catch (AssertionFailedError t) {
323              threadRecordFailure(t);
324              throw t;
325          }
# Line 313 | Line 327 | public class JSR166TestCase extends Test
327  
328      /**
329       * Just like assertEquals(x, y), but additionally recording (using
330 <     * threadRecordFailure) any AssertionError thrown, so that the
331 <     * current testcase will fail.
330 >     * threadRecordFailure) any AssertionFailedError thrown, so that
331 >     * the current testcase will fail.
332       */
333      public void threadAssertEquals(long x, long y) {
334          try {
335              assertEquals(x, y);
336 <        } catch (AssertionError t) {
336 >        } catch (AssertionFailedError t) {
337              threadRecordFailure(t);
338              throw t;
339          }
# Line 327 | Line 341 | public class JSR166TestCase extends Test
341  
342      /**
343       * Just like assertEquals(x, y), but additionally recording (using
344 <     * threadRecordFailure) any AssertionError thrown, so that the
345 <     * current testcase will fail.
344 >     * threadRecordFailure) any AssertionFailedError thrown, so that
345 >     * the current testcase will fail.
346       */
347      public void threadAssertEquals(Object x, Object y) {
348          try {
349              assertEquals(x, y);
350 <        } catch (AssertionError t) {
350 >        } catch (AssertionFailedError t) {
351              threadRecordFailure(t);
352              throw t;
353 +        } catch (Throwable t) {
354 +            threadUnexpectedException(t);
355          }
356      }
357  
358      /**
359       * Just like assertSame(x, y), but additionally recording (using
360 <     * threadRecordFailure) any AssertionError thrown, so that the
361 <     * current testcase will fail.
360 >     * threadRecordFailure) any AssertionFailedError thrown, so that
361 >     * the current testcase will fail.
362       */
363      public void threadAssertSame(Object x, Object y) {
364          try {
365              assertSame(x, y);
366 <        } catch (AssertionError t) {
366 >        } catch (AssertionFailedError t) {
367              threadRecordFailure(t);
368              throw t;
369          }
# Line 368 | Line 384 | public class JSR166TestCase extends Test
384      }
385  
386      /**
387 <     * Calls threadFail with message "Unexpected exception" + ex.
387 >     * Records the given exception using {@link #threadRecordFailure},
388 >     * then rethrows the exception, wrapping it in an
389 >     * AssertionFailedError if necessary.
390       */
391      public void threadUnexpectedException(Throwable t) {
392          threadRecordFailure(t);
393          t.printStackTrace();
376 –        // Rethrow, wrapping in an AssertionError if necessary
394          if (t instanceof RuntimeException)
395              throw (RuntimeException) t;
396          else if (t instanceof Error)
397              throw (Error) t;
398          else {
399 <            AssertionError ae = new AssertionError("unexpected exception: " + t);
399 >            AssertionFailedError afe =
400 >                new AssertionFailedError("unexpected exception: " + t);
401              t.initCause(t);
402 <            throw ae;
402 >            throw afe;
403          }
404      }
405  
# Line 416 | Line 434 | public class JSR166TestCase extends Test
434      }
435  
436      /**
419 –     * Fails with message "Unexpected exception: " + ex.
420 –     */
421 –    public void unexpectedException(Throwable ex) {
422 –        ex.printStackTrace();
423 –        fail("Unexpected exception: " + ex);
424 –    }
425 –
426 –
427 –    /**
437       * The number of elements to place in collections, arrays, etc.
438       */
439      public static final int SIZE = 20;
# Line 535 | Line 544 | public class JSR166TestCase extends Test
544      }
545  
546      /**
547 <     * Sleep until the timeout has elapsed, or interrupted.
547 >     * Sleeps until the given time has elapsed.
548 >     * Throws AssertionFailedError if interrupted.
549 >     */
550 >    void sleep(long millis) {
551 >        try {
552 >            Thread.sleep(millis);
553 >        } catch (InterruptedException ie) {
554 >            AssertionFailedError afe =
555 >                new AssertionFailedError("Unexpected InterruptedException");
556 >            afe.initCause(ie);
557 >            throw afe;
558 >        }
559 >    }
560 >
561 >    /**
562 >     * Sleeps until the timeout has elapsed, or interrupted.
563       * Does <em>NOT</em> throw InterruptedException.
564       */
565      void sleepTillInterrupted(long timeoutMillis) {
# Line 545 | Line 569 | public class JSR166TestCase extends Test
569      }
570  
571      /**
572 <     * Returns a new started Thread running the given runnable.
572 >     * Returns a new started daemon Thread running the given runnable.
573       */
574      Thread newStartedThread(Runnable runnable) {
575          Thread t = new Thread(runnable);
576 +        t.setDaemon(true);
577          t.start();
578          return t;
579      }
580  
581 +    /**
582 +     * Waits for the specified time (in milliseconds) for the thread
583 +     * to terminate (using {@link Thread#join(long)}), else interrupts
584 +     * the thread (in the hope that it may terminate later) and fails.
585 +     */
586 +    void awaitTermination(Thread t, long timeoutMillis) {
587 +        try {
588 +            t.join(timeoutMillis);
589 +        } catch (InterruptedException ie) {
590 +            threadUnexpectedException(ie);
591 +        } finally {
592 +            if (t.isAlive()) {
593 +                t.interrupt();
594 +                fail("Test timed out");
595 +            }
596 +        }
597 +    }
598 +
599      // Some convenient Runnable classes
600  
601      public abstract class CheckedRunnable implements Runnable {
# Line 716 | Line 759 | public class JSR166TestCase extends Test
759          }
760      }
761  
719 –    public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
720 –        protected void realRun() throws InterruptedException {
721 –            Thread.sleep(SMALL_DELAY_MS);
722 –        }
723 –    }
724 –
762      public class MediumRunnable extends CheckedRunnable {
763          protected void realRun() throws Throwable {
764              Thread.sleep(MEDIUM_DELAY_MS);
# Line 846 | Line 883 | public class JSR166TestCase extends Test
883                                        ThreadPoolExecutor executor) {}
884      }
885  
886 +    /**
887 +     * A CyclicBarrier that fails with AssertionFailedErrors instead
888 +     * of throwing checked exceptions.
889 +     */
890 +    public class CheckedBarrier extends CyclicBarrier {
891 +        public CheckedBarrier(int parties) { super(parties); }
892 +
893 +        public int await() {
894 +            try {
895 +                return super.await();
896 +            } catch (Exception e) {
897 +                AssertionFailedError afe =
898 +                    new AssertionFailedError("Unexpected exception: " + e);
899 +                afe.initCause(e);
900 +                throw afe;
901 +            }
902 +        }
903 +    }
904 +
905   }

Diff Legend

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