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.1 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.95 by jsr166, Mon Jan 21 19:43:52 2013 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
2 > * Written by Doug Lea with assistance from members of JCP JSR-166
3 > * Expert Group and released to the public domain, as explained at
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
10 < import java.util.*;
10 > import java.io.ByteArrayInputStream;
11 > import java.io.ByteArrayOutputStream;
12 > import java.io.ObjectInputStream;
13 > import java.io.ObjectOutputStream;
14 > import java.util.ArrayList;
15 > import java.util.Arrays;
16 > import java.util.Date;
17 > import java.util.Enumeration;
18 > import java.util.List;
19 > import java.util.NoSuchElementException;
20 > import java.util.PropertyPermission;
21   import java.util.concurrent.*;
22 < import java.io.*;
23 <
22 > import java.util.concurrent.atomic.AtomicBoolean;
23 > import java.util.concurrent.atomic.AtomicReference;
24 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
25 > import static java.util.concurrent.TimeUnit.NANOSECONDS;
26 > import java.security.CodeSource;
27 > import java.security.Permission;
28 > import java.security.PermissionCollection;
29 > import java.security.Permissions;
30 > import java.security.Policy;
31 > import java.security.ProtectionDomain;
32 > import java.security.SecurityPermission;
33  
34   /**
35 < * Base class for JSR166 Junit TCK tests.  Defines some constants and
36 < * utility methods, as well as a simple framework for helping to make
37 < * sure that assertions failing in generated threads cause the
38 < * associated test that generated them to itself fail (which JUnit doe
39 < * not otherwise arrange).  The rules for creating such tests are:
35 > * Base class for JSR166 Junit TCK tests.  Defines some constants,
36 > * utility methods and classes, as well as a simple framework for
37 > * helping to make sure that assertions failing in generated threads
38 > * cause the associated test that generated them to itself fail (which
39 > * JUnit does not otherwise arrange).  The rules for creating such
40 > * tests are:
41   *
42   * <ol>
43   *
44   * <li> All assertions in code running in generated threads must use
45 < * the forms {@link threadFail} , {@link threadAssertTrue} {@link
46 < * threadAssertEquals}, or {@link threadAssertNull}, (not
47 < * <tt>fail</tt>, <tt>assertTrue</tt>, etc.) It is OK (but not
45 > * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link
46 > * #threadAssertEquals}, or {@link #threadAssertNull}, (not
47 > * {@code fail}, {@code assertTrue}, etc.) It is OK (but not
48   * particularly recommended) for other code to use these forms too.
49   * Only the most typically used JUnit assertion methods are defined
50   * this way, but enough to live with.</li>
51   *
52 < * <li> If you override {@link setUp} or {@link tearDown}, make sure
53 < * to invoke <tt>super.setUp</tt> and <tt>super.tearDown</tt> within
52 > * <li> If you override {@link #setUp} or {@link #tearDown}, make sure
53 > * to invoke {@code super.setUp} and {@code super.tearDown} within
54   * them. These methods are used to clear and check for thread
55   * assertion failures.</li>
56   *
57 < * <li>All delays and timeouts must use one of the constants {@link
58 < * SHORT_DELAY_MS}, {@link SMALL_DELAY_MS}, {@link MEDIUM_DELAY_MS},
59 < * {@link LONG_DELAY_MS}. The idea here is that a SHORT is always
60 < * discriminatable from zero time, and always allows enough time for
61 < * the small amounts of computation (creating a thread, calling a few
57 > * <li>All delays and timeouts must use one of the constants {@code
58 > * SHORT_DELAY_MS}, {@code SMALL_DELAY_MS}, {@code MEDIUM_DELAY_MS},
59 > * {@code LONG_DELAY_MS}. The idea here is that a SHORT is always
60 > * discriminable from zero time, and always allows enough time for the
61 > * small amounts of computation (creating a thread, calling a few
62   * methods, etc) needed to reach a timeout point. Similarly, a SMALL
63   * is always discriminable as larger than SHORT and smaller than
64   * MEDIUM.  And so on. These constants are set to conservative values,
65 < * (100, 500, 1000, 5000 MS) but even so, if there is ever any doubt,
66 < * they can all be increased in one spot to rerun tests on slower
46 < * platforms</li>
65 > * but even so, if there is ever any doubt, they can all be increased
66 > * in one spot to rerun tests on slower platforms.</li>
67   *
68   * <li> All threads generated must be joined inside each test case
69 < * method (or <tt>fail</tt> to do so) before returning from the
70 < * method. The {@link joinPool} method can be used to do this when
69 > * method (or {@code fail} to do so) before returning from the
70 > * method. The {@code joinPool} method can be used to do this when
71   * using Executors.</li>
72   *
73   * </ol>
74 + *
75 + * <p><b>Other notes</b>
76 + * <ul>
77 + *
78 + * <li> Usually, there is one testcase method per JSR166 method
79 + * covering "normal" operation, and then as many exception-testing
80 + * methods as there are exceptions the method can throw. Sometimes
81 + * there are multiple tests per JSR166 method when the different
82 + * "normal" behaviors differ significantly. And sometimes testcases
83 + * cover multiple methods when they cannot be tested in
84 + * isolation.</li>
85 + *
86 + * <li> The documentation style for testcases is to provide as javadoc
87 + * a simple sentence or two describing the property that the testcase
88 + * method purports to test. The javadocs do not say anything about how
89 + * the property is tested. To find out, read the code.</li>
90 + *
91 + * <li> These tests are "conformance tests", and do not attempt to
92 + * test throughput, latency, scalability or other performance factors
93 + * (see the separate "jtreg" tests for a set intended to check these
94 + * for the most central aspects of functionality.) So, most tests use
95 + * the smallest sensible numbers of threads, collection sizes, etc
96 + * needed to check basic conformance.</li>
97 + *
98 + * <li>The test classes currently do not declare inclusion in
99 + * any particular package to simplify things for people integrating
100 + * them in TCK test suites.</li>
101 + *
102 + * <li> As a convenience, the {@code main} of this class (JSR166TestCase)
103 + * runs all JSR166 unit tests.</li>
104 + *
105 + * </ul>
106   */
107   public class JSR166TestCase extends TestCase {
108 +    private static final boolean useSecurityManager =
109 +        Boolean.getBoolean("jsr166.useSecurityManager");
110 +
111 +    protected static final boolean expensiveTests =
112 +        Boolean.getBoolean("jsr166.expensiveTests");
113 +
114 +    /**
115 +     * If true, report on stdout all "slow" tests, that is, ones that
116 +     * take more than profileThreshold milliseconds to execute.
117 +     */
118 +    private static final boolean profileTests =
119 +        Boolean.getBoolean("jsr166.profileTests");
120 +
121 +    /**
122 +     * The number of milliseconds that tests are permitted for
123 +     * execution without being reported, when profileTests is set.
124 +     */
125 +    private static final long profileThreshold =
126 +        Long.getLong("jsr166.profileThreshold", 100);
127 +
128 +    protected void runTest() throws Throwable {
129 +        if (profileTests)
130 +            runTestProfiled();
131 +        else
132 +            super.runTest();
133 +    }
134 +
135 +    protected void runTestProfiled() throws Throwable {
136 +        long t0 = System.nanoTime();
137 +        try {
138 +            super.runTest();
139 +        } finally {
140 +            long elapsedMillis =
141 +                (System.nanoTime() - t0) / (1000L * 1000L);
142 +            if (elapsedMillis >= profileThreshold)
143 +                System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
144 +        }
145 +    }
146 +
147 +    /**
148 +     * Runs all JSR166 unit tests using junit.textui.TestRunner.
149 +     * Optional command line arg provides the number of iterations to
150 +     * repeat running the tests.
151 +     */
152 +    public static void main(String[] args) {
153 +        if (useSecurityManager) {
154 +            System.err.println("Setting a permissive security manager");
155 +            Policy.setPolicy(permissivePolicy());
156 +            System.setSecurityManager(new SecurityManager());
157 +        }
158 +        int iters = (args.length == 0) ? 1 : Integer.parseInt(args[0]);
159 +
160 +        Test s = suite();
161 +        for (int i = 0; i < iters; ++i) {
162 +            junit.textui.TestRunner.run(s);
163 +            System.gc();
164 +            System.runFinalization();
165 +        }
166 +        System.exit(0);
167 +    }
168 +
169 +    public static TestSuite newTestSuite(Object... suiteOrClasses) {
170 +        TestSuite suite = new TestSuite();
171 +        for (Object suiteOrClass : suiteOrClasses) {
172 +            if (suiteOrClass instanceof TestSuite)
173 +                suite.addTest((TestSuite) suiteOrClass);
174 +            else if (suiteOrClass instanceof Class)
175 +                suite.addTest(new TestSuite((Class<?>) suiteOrClass));
176 +            else
177 +                throw new ClassCastException("not a test suite or class");
178 +        }
179 +        return suite;
180 +    }
181 +
182 +    /**
183 +     * Collects all JSR166 unit tests as one suite.
184 +     */
185 +    public static Test suite() {
186 +        return newTestSuite(
187 +            ForkJoinPoolTest.suite(),
188 +            ForkJoinTaskTest.suite(),
189 +            RecursiveActionTest.suite(),
190 +            RecursiveTaskTest.suite(),
191 +            LinkedTransferQueueTest.suite(),
192 +            PhaserTest.suite(),
193 +            ThreadLocalRandomTest.suite(),
194 +            AbstractExecutorServiceTest.suite(),
195 +            AbstractQueueTest.suite(),
196 +            AbstractQueuedSynchronizerTest.suite(),
197 +            AbstractQueuedLongSynchronizerTest.suite(),
198 +            ArrayBlockingQueueTest.suite(),
199 +            ArrayDequeTest.suite(),
200 +            AtomicBooleanTest.suite(),
201 +            AtomicIntegerArrayTest.suite(),
202 +            AtomicIntegerFieldUpdaterTest.suite(),
203 +            AtomicIntegerTest.suite(),
204 +            AtomicLongArrayTest.suite(),
205 +            AtomicLongFieldUpdaterTest.suite(),
206 +            AtomicLongTest.suite(),
207 +            AtomicMarkableReferenceTest.suite(),
208 +            AtomicReferenceArrayTest.suite(),
209 +            AtomicReferenceFieldUpdaterTest.suite(),
210 +            AtomicReferenceTest.suite(),
211 +            AtomicStampedReferenceTest.suite(),
212 +            ConcurrentHashMapTest.suite(),
213 +            ConcurrentLinkedDequeTest.suite(),
214 +            ConcurrentLinkedQueueTest.suite(),
215 +            ConcurrentSkipListMapTest.suite(),
216 +            ConcurrentSkipListSubMapTest.suite(),
217 +            ConcurrentSkipListSetTest.suite(),
218 +            ConcurrentSkipListSubSetTest.suite(),
219 +            CopyOnWriteArrayListTest.suite(),
220 +            CopyOnWriteArraySetTest.suite(),
221 +            CountDownLatchTest.suite(),
222 +            CyclicBarrierTest.suite(),
223 +            DelayQueueTest.suite(),
224 +            EntryTest.suite(),
225 +            ExchangerTest.suite(),
226 +            ExecutorsTest.suite(),
227 +            ExecutorCompletionServiceTest.suite(),
228 +            FutureTaskTest.suite(),
229 +            LinkedBlockingDequeTest.suite(),
230 +            LinkedBlockingQueueTest.suite(),
231 +            LinkedListTest.suite(),
232 +            LockSupportTest.suite(),
233 +            PriorityBlockingQueueTest.suite(),
234 +            PriorityQueueTest.suite(),
235 +            ReentrantLockTest.suite(),
236 +            ReentrantReadWriteLockTest.suite(),
237 +            ScheduledExecutorTest.suite(),
238 +            ScheduledExecutorSubclassTest.suite(),
239 +            SemaphoreTest.suite(),
240 +            SynchronousQueueTest.suite(),
241 +            SystemTest.suite(),
242 +            ThreadLocalTest.suite(),
243 +            ThreadPoolExecutorTest.suite(),
244 +            ThreadPoolExecutorSubclassTest.suite(),
245 +            ThreadTest.suite(),
246 +            TimeUnitTest.suite(),
247 +            TreeMapTest.suite(),
248 +            TreeSetTest.suite(),
249 +            TreeSubMapTest.suite(),
250 +            TreeSubSetTest.suite());
251 +    }
252 +
253 +
254 +    public static long SHORT_DELAY_MS;
255 +    public static long SMALL_DELAY_MS;
256 +    public static long MEDIUM_DELAY_MS;
257 +    public static long LONG_DELAY_MS;
258 +
259 +
260 +    /**
261 +     * Returns the shortest timed delay. This could
262 +     * be reimplemented to use for example a Property.
263 +     */
264 +    protected long getShortDelay() {
265 +        return 50;
266 +    }
267 +
268 +    /**
269 +     * Sets delays as multiples of SHORT_DELAY.
270 +     */
271 +    protected void setDelays() {
272 +        SHORT_DELAY_MS = getShortDelay();
273 +        SMALL_DELAY_MS  = SHORT_DELAY_MS * 5;
274 +        MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10;
275 +        LONG_DELAY_MS   = SHORT_DELAY_MS * 200;
276 +    }
277  
278      /**
279 <     * Flag set true if any threadAssert methods fail
279 >     * Returns a timeout in milliseconds to be used in tests that
280 >     * verify that operations block or time out.
281       */
282 <    protected volatile boolean threadFailed;
282 >    long timeoutMillis() {
283 >        return SHORT_DELAY_MS / 4;
284 >    }
285  
286      /**
287 <     * Initialize test to indicat that no thread assertions have failed
287 >     * Returns a new Date instance representing a time delayMillis
288 >     * milliseconds in the future.
289       */
290 <    public void setUp() {
291 <        threadFailed = false;  
290 >    Date delayedDate(long delayMillis) {
291 >        return new Date(System.currentTimeMillis() + delayMillis);
292      }
293  
294      /**
295 <     * Trigger test case failure if any thread assertions have failed
295 >     * The first exception encountered if any threadAssertXXX method fails.
296 >     */
297 >    private final AtomicReference<Throwable> threadFailure
298 >        = new AtomicReference<Throwable>(null);
299 >
300 >    /**
301 >     * Records an exception so that it can be rethrown later in the test
302 >     * harness thread, triggering a test case failure.  Only the first
303 >     * failure is recorded; subsequent calls to this method from within
304 >     * the same test have no effect.
305       */
306 <    public void tearDown() {
307 <        assertFalse(threadFailed);  
306 >    public void threadRecordFailure(Throwable t) {
307 >        threadFailure.compareAndSet(null, t);
308 >    }
309 >
310 >    public void setUp() {
311 >        setDelays();
312      }
313  
314 +    /**
315 +     * Extra checks that get done for all test cases.
316 +     *
317 +     * Triggers test case failure if any thread assertions have failed,
318 +     * by rethrowing, in the test harness thread, any exception recorded
319 +     * earlier by threadRecordFailure.
320 +     *
321 +     * Triggers test case failure if interrupt status is set in the main thread.
322 +     */
323 +    public void tearDown() throws Exception {
324 +        Throwable t = threadFailure.getAndSet(null);
325 +        if (t != null) {
326 +            if (t instanceof Error)
327 +                throw (Error) t;
328 +            else if (t instanceof RuntimeException)
329 +                throw (RuntimeException) t;
330 +            else if (t instanceof Exception)
331 +                throw (Exception) t;
332 +            else {
333 +                AssertionFailedError afe =
334 +                    new AssertionFailedError(t.toString());
335 +                afe.initCause(t);
336 +                throw afe;
337 +            }
338 +        }
339 +
340 +        if (Thread.interrupted())
341 +            throw new AssertionFailedError("interrupt status set in main thread");
342 +    }
343 +
344 +    /**
345 +     * Just like fail(reason), but additionally recording (using
346 +     * threadRecordFailure) any AssertionFailedError thrown, so that
347 +     * the current testcase will fail.
348 +     */
349      public void threadFail(String reason) {
350 <        threadFailed = true;
351 <        fail(reason);
350 >        try {
351 >            fail(reason);
352 >        } catch (AssertionFailedError t) {
353 >            threadRecordFailure(t);
354 >            fail(reason);
355 >        }
356      }
357  
358 +    /**
359 +     * Just like assertTrue(b), but additionally recording (using
360 +     * threadRecordFailure) any AssertionFailedError thrown, so that
361 +     * the current testcase will fail.
362 +     */
363      public void threadAssertTrue(boolean b) {
364 <        if (!b) {
83 <            threadFailed = true;
364 >        try {
365              assertTrue(b);
366 +        } catch (AssertionFailedError t) {
367 +            threadRecordFailure(t);
368 +            throw t;
369          }
370      }
371 +
372 +    /**
373 +     * Just like assertFalse(b), but additionally recording (using
374 +     * threadRecordFailure) any AssertionFailedError thrown, so that
375 +     * the current testcase will fail.
376 +     */
377      public void threadAssertFalse(boolean b) {
378 <        if (b) {
89 <            threadFailed = true;
378 >        try {
379              assertFalse(b);
380 +        } catch (AssertionFailedError t) {
381 +            threadRecordFailure(t);
382 +            throw t;
383          }
384      }
385 +
386 +    /**
387 +     * Just like assertNull(x), but additionally recording (using
388 +     * threadRecordFailure) any AssertionFailedError thrown, so that
389 +     * the current testcase will fail.
390 +     */
391      public void threadAssertNull(Object x) {
392 <        if (x != null) {
95 <            threadFailed = true;
392 >        try {
393              assertNull(x);
394 +        } catch (AssertionFailedError t) {
395 +            threadRecordFailure(t);
396 +            throw t;
397          }
398      }
399 +
400 +    /**
401 +     * Just like assertEquals(x, y), but additionally recording (using
402 +     * threadRecordFailure) any AssertionFailedError thrown, so that
403 +     * the current testcase will fail.
404 +     */
405      public void threadAssertEquals(long x, long y) {
406 <        if (x != y) {
101 <            threadFailed = true;
406 >        try {
407              assertEquals(x, y);
408 +        } catch (AssertionFailedError t) {
409 +            threadRecordFailure(t);
410 +            throw t;
411          }
412      }
413 +
414 +    /**
415 +     * Just like assertEquals(x, y), but additionally recording (using
416 +     * threadRecordFailure) any AssertionFailedError thrown, so that
417 +     * the current testcase will fail.
418 +     */
419      public void threadAssertEquals(Object x, Object y) {
420 <        if (x != y && (x == null || !x.equals(y))) {
107 <            threadFailed = true;
420 >        try {
421              assertEquals(x, y);
422 +        } catch (AssertionFailedError t) {
423 +            threadRecordFailure(t);
424 +            throw t;
425 +        } catch (Throwable t) {
426 +            threadUnexpectedException(t);
427 +        }
428 +    }
429 +
430 +    /**
431 +     * Just like assertSame(x, y), but additionally recording (using
432 +     * threadRecordFailure) any AssertionFailedError thrown, so that
433 +     * the current testcase will fail.
434 +     */
435 +    public void threadAssertSame(Object x, Object y) {
436 +        try {
437 +            assertSame(x, y);
438 +        } catch (AssertionFailedError t) {
439 +            threadRecordFailure(t);
440 +            throw t;
441 +        }
442 +    }
443 +
444 +    /**
445 +     * Calls threadFail with message "should throw exception".
446 +     */
447 +    public void threadShouldThrow() {
448 +        threadFail("should throw exception");
449 +    }
450 +
451 +    /**
452 +     * Calls threadFail with message "should throw" + exceptionName.
453 +     */
454 +    public void threadShouldThrow(String exceptionName) {
455 +        threadFail("should throw " + exceptionName);
456 +    }
457 +
458 +    /**
459 +     * Records the given exception using {@link #threadRecordFailure},
460 +     * then rethrows the exception, wrapping it in an
461 +     * AssertionFailedError if necessary.
462 +     */
463 +    public void threadUnexpectedException(Throwable t) {
464 +        threadRecordFailure(t);
465 +        t.printStackTrace();
466 +        if (t instanceof RuntimeException)
467 +            throw (RuntimeException) t;
468 +        else if (t instanceof Error)
469 +            throw (Error) t;
470 +        else {
471 +            AssertionFailedError afe =
472 +                new AssertionFailedError("unexpected exception: " + t);
473 +            afe.initCause(t);
474 +            throw afe;
475          }
476      }
477  
478      /**
479 <     * Wait out termination of a thread pool or fail doing so
479 >     * Delays, via Thread.sleep, for the given millisecond delay, but
480 >     * if the sleep is shorter than specified, may re-sleep or yield
481 >     * until time elapses.
482       */
483 <    public void joinPool(ExecutorService exec) {
483 >    static void delay(long millis) throws InterruptedException {
484 >        long startTime = System.nanoTime();
485 >        long ns = millis * 1000 * 1000;
486 >        for (;;) {
487 >            if (millis > 0L)
488 >                Thread.sleep(millis);
489 >            else // too short to sleep
490 >                Thread.yield();
491 >            long d = ns - (System.nanoTime() - startTime);
492 >            if (d > 0L)
493 >                millis = d / (1000 * 1000);
494 >            else
495 >                break;
496 >        }
497 >    }
498 >
499 >    /**
500 >     * Waits out termination of a thread pool or fails doing so.
501 >     */
502 >    void joinPool(ExecutorService exec) {
503          try {
504              exec.shutdown();
505 <            assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
506 <        } catch(InterruptedException ie) {
507 <            fail("unexpected exception");
505 >            assertTrue("ExecutorService did not terminate in a timely manner",
506 >                       exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS));
507 >        } catch (SecurityException ok) {
508 >            // Allowed in case test doesn't have privs
509 >        } catch (InterruptedException ie) {
510 >            fail("Unexpected InterruptedException");
511 >        }
512 >    }
513 >
514 >    /**
515 >     * A debugging tool to print all stack traces, as jstack does.
516 >     */
517 >    void printAllStackTraces() {
518 >        System.err.println(
519 >            Arrays.toString(
520 >                java.lang.management.ManagementFactory.getThreadMXBean()
521 >                .dumpAllThreads(true, true)));
522 >    }
523 >
524 >    /**
525 >     * Checks that thread does not terminate within the default
526 >     * millisecond delay of {@code timeoutMillis()}.
527 >     */
528 >    void assertThreadStaysAlive(Thread thread) {
529 >        assertThreadStaysAlive(thread, timeoutMillis());
530 >    }
531 >
532 >    /**
533 >     * Checks that thread does not terminate within the given millisecond delay.
534 >     */
535 >    void assertThreadStaysAlive(Thread thread, long millis) {
536 >        try {
537 >            // No need to optimize the failing case via Thread.join.
538 >            delay(millis);
539 >            assertTrue(thread.isAlive());
540 >        } catch (InterruptedException ie) {
541 >            fail("Unexpected InterruptedException");
542          }
543      }
544  
545 <    public static final long SHORT_DELAY_MS =   100;
546 <    public static final long SMALL_DELAY_MS =   500;
547 <    public static final long MEDIUM_DELAY_MS = 1000;
548 <    public static final long LONG_DELAY_MS =   5000;
545 >    /**
546 >     * Checks that the threads do not terminate within the default
547 >     * millisecond delay of {@code timeoutMillis()}.
548 >     */
549 >    void assertThreadsStayAlive(Thread... threads) {
550 >        assertThreadsStayAlive(timeoutMillis(), threads);
551 >    }
552 >
553 >    /**
554 >     * Checks that the threads do not terminate within the given millisecond delay.
555 >     */
556 >    void assertThreadsStayAlive(long millis, Thread... threads) {
557 >        try {
558 >            // No need to optimize the failing case via Thread.join.
559 >            delay(millis);
560 >            for (Thread thread : threads)
561 >                assertTrue(thread.isAlive());
562 >        } catch (InterruptedException ie) {
563 >            fail("Unexpected InterruptedException");
564 >        }
565 >    }
566 >
567 >    /**
568 >     * Checks that future.get times out, with the default timeout of
569 >     * {@code timeoutMillis()}.
570 >     */
571 >    void assertFutureTimesOut(Future future) {
572 >        assertFutureTimesOut(future, timeoutMillis());
573 >    }
574 >
575 >    /**
576 >     * Checks that future.get times out, with the given millisecond timeout.
577 >     */
578 >    void assertFutureTimesOut(Future future, long timeoutMillis) {
579 >        long startTime = System.nanoTime();
580 >        try {
581 >            future.get(timeoutMillis, MILLISECONDS);
582 >            shouldThrow();
583 >        } catch (TimeoutException success) {
584 >        } catch (Exception e) {
585 >            threadUnexpectedException(e);
586 >        } finally { future.cancel(true); }
587 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
588 >    }
589 >
590 >    /**
591 >     * Fails with message "should throw exception".
592 >     */
593 >    public void shouldThrow() {
594 >        fail("Should throw exception");
595 >    }
596  
597 +    /**
598 +     * Fails with message "should throw " + exceptionName.
599 +     */
600 +    public void shouldThrow(String exceptionName) {
601 +        fail("Should throw " + exceptionName);
602 +    }
603  
604      /**
605       * The number of elements to place in collections, arrays, etc.
# Line 134 | Line 608 | public class JSR166TestCase extends Test
608  
609      // Some convenient Integer constants
610  
611 <    public static final Integer zero = new Integer(0);
612 <    public static final Integer one = new Integer(1);
613 <    public static final Integer two = new Integer(2);
614 <    public static final Integer three  = new Integer(3);
611 >    public static final Integer zero  = new Integer(0);
612 >    public static final Integer one   = new Integer(1);
613 >    public static final Integer two   = new Integer(2);
614 >    public static final Integer three = new Integer(3);
615      public static final Integer four  = new Integer(4);
616      public static final Integer five  = new Integer(5);
617 <    public static final Integer six = new Integer(6);
617 >    public static final Integer six   = new Integer(6);
618      public static final Integer seven = new Integer(7);
619      public static final Integer eight = new Integer(8);
620 <    public static final Integer nine = new Integer(9);
620 >    public static final Integer nine  = new Integer(9);
621      public static final Integer m1  = new Integer(-1);
622      public static final Integer m2  = new Integer(-2);
623      public static final Integer m3  = new Integer(-3);
624 <    public static final Integer m4 = new Integer(-4);
625 <    public static final Integer m5 = new Integer(-5);
624 >    public static final Integer m4  = new Integer(-4);
625 >    public static final Integer m5  = new Integer(-5);
626 >    public static final Integer m6  = new Integer(-6);
627      public static final Integer m10 = new Integer(-10);
628  
629  
630 <    // Some convenient Runnable classes
630 >    /**
631 >     * Runs Runnable r with a security policy that permits precisely
632 >     * the specified permissions.  If there is no current security
633 >     * manager, the runnable is run twice, both with and without a
634 >     * security manager.  We require that any security manager permit
635 >     * getPolicy/setPolicy.
636 >     */
637 >    public void runWithPermissions(Runnable r, Permission... permissions) {
638 >        SecurityManager sm = System.getSecurityManager();
639 >        if (sm == null) {
640 >            r.run();
641 >        }
642 >        runWithSecurityManagerWithPermissions(r, permissions);
643 >    }
644  
645 <    public static class NoOpRunnable implements Runnable {
646 <        public void run() {}
645 >    /**
646 >     * Runs Runnable r with a security policy that permits precisely
647 >     * the specified permissions.  If there is no current security
648 >     * manager, a temporary one is set for the duration of the
649 >     * Runnable.  We require that any security manager permit
650 >     * getPolicy/setPolicy.
651 >     */
652 >    public void runWithSecurityManagerWithPermissions(Runnable r,
653 >                                                      Permission... permissions) {
654 >        SecurityManager sm = System.getSecurityManager();
655 >        if (sm == null) {
656 >            Policy savedPolicy = Policy.getPolicy();
657 >            try {
658 >                Policy.setPolicy(permissivePolicy());
659 >                System.setSecurityManager(new SecurityManager());
660 >                runWithSecurityManagerWithPermissions(r, permissions);
661 >            } finally {
662 >                System.setSecurityManager(null);
663 >                Policy.setPolicy(savedPolicy);
664 >            }
665 >        } else {
666 >            Policy savedPolicy = Policy.getPolicy();
667 >            AdjustablePolicy policy = new AdjustablePolicy(permissions);
668 >            Policy.setPolicy(policy);
669 >
670 >            try {
671 >                r.run();
672 >            } finally {
673 >                policy.addPermission(new SecurityPermission("setPolicy"));
674 >                Policy.setPolicy(savedPolicy);
675 >            }
676 >        }
677      }
678  
679 <    public static class NoOpCallable implements Callable {
680 <        public Object call() { return Boolean.TRUE; }
679 >    /**
680 >     * Runs a runnable without any permissions.
681 >     */
682 >    public void runWithoutPermissions(Runnable r) {
683 >        runWithPermissions(r);
684      }
685  
686 <    public class ShortRunnable implements Runnable {
687 <        public void run() {
688 <            try {
689 <                Thread.sleep(SHORT_DELAY_MS);
686 >    /**
687 >     * A security policy where new permissions can be dynamically added
688 >     * or all cleared.
689 >     */
690 >    public static class AdjustablePolicy extends java.security.Policy {
691 >        Permissions perms = new Permissions();
692 >        AdjustablePolicy(Permission... permissions) {
693 >            for (Permission permission : permissions)
694 >                perms.add(permission);
695 >        }
696 >        void addPermission(Permission perm) { perms.add(perm); }
697 >        void clearPermissions() { perms = new Permissions(); }
698 >        public PermissionCollection getPermissions(CodeSource cs) {
699 >            return perms;
700 >        }
701 >        public PermissionCollection getPermissions(ProtectionDomain pd) {
702 >            return perms;
703 >        }
704 >        public boolean implies(ProtectionDomain pd, Permission p) {
705 >            return perms.implies(p);
706 >        }
707 >        public void refresh() {}
708 >        public String toString() {
709 >            List<Permission> ps = new ArrayList<Permission>();
710 >            for (Enumeration<Permission> e = perms.elements(); e.hasMoreElements();)
711 >                ps.add(e.nextElement());
712 >            return "AdjustablePolicy with permissions " + ps;
713 >        }
714 >    }
715 >
716 >    /**
717 >     * Returns a policy containing all the permissions we ever need.
718 >     */
719 >    public static Policy permissivePolicy() {
720 >        return new AdjustablePolicy
721 >            // Permissions j.u.c. needs directly
722 >            (new RuntimePermission("modifyThread"),
723 >             new RuntimePermission("getClassLoader"),
724 >             new RuntimePermission("setContextClassLoader"),
725 >             // Permissions needed to change permissions!
726 >             new SecurityPermission("getPolicy"),
727 >             new SecurityPermission("setPolicy"),
728 >             new RuntimePermission("setSecurityManager"),
729 >             // Permissions needed by the junit test harness
730 >             new RuntimePermission("accessDeclaredMembers"),
731 >             new PropertyPermission("*", "read"),
732 >             new java.io.FilePermission("<<ALL FILES>>", "read"));
733 >    }
734 >
735 >    /**
736 >     * Sleeps until the given time has elapsed.
737 >     * Throws AssertionFailedError if interrupted.
738 >     */
739 >    void sleep(long millis) {
740 >        try {
741 >            delay(millis);
742 >        } catch (InterruptedException ie) {
743 >            AssertionFailedError afe =
744 >                new AssertionFailedError("Unexpected InterruptedException");
745 >            afe.initCause(ie);
746 >            throw afe;
747 >        }
748 >    }
749 >
750 >    /**
751 >     * Spin-waits up to the specified number of milliseconds for the given
752 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
753 >     */
754 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
755 >        long startTime = System.nanoTime();
756 >        for (;;) {
757 >            Thread.State s = thread.getState();
758 >            if (s == Thread.State.BLOCKED ||
759 >                s == Thread.State.WAITING ||
760 >                s == Thread.State.TIMED_WAITING)
761 >                return;
762 >            else if (s == Thread.State.TERMINATED)
763 >                fail("Unexpected thread termination");
764 >            else if (millisElapsedSince(startTime) > timeoutMillis) {
765 >                threadAssertTrue(thread.isAlive());
766 >                return;
767              }
768 <            catch(Exception e) {
769 <                threadFail("unexpectedException");
768 >            Thread.yield();
769 >        }
770 >    }
771 >
772 >    /**
773 >     * Waits up to LONG_DELAY_MS for the given thread to enter a wait
774 >     * state: BLOCKED, WAITING, or TIMED_WAITING.
775 >     */
776 >    void waitForThreadToEnterWaitState(Thread thread) {
777 >        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
778 >    }
779 >
780 >    /**
781 >     * Returns the number of milliseconds since time given by
782 >     * startNanoTime, which must have been previously returned from a
783 >     * call to {@link System.nanoTime()}.
784 >     */
785 >    long millisElapsedSince(long startNanoTime) {
786 >        return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
787 >    }
788 >
789 >    /**
790 >     * Returns a new started daemon Thread running the given runnable.
791 >     */
792 >    Thread newStartedThread(Runnable runnable) {
793 >        Thread t = new Thread(runnable);
794 >        t.setDaemon(true);
795 >        t.start();
796 >        return t;
797 >    }
798 >
799 >    /**
800 >     * Waits for the specified time (in milliseconds) for the thread
801 >     * to terminate (using {@link Thread#join(long)}), else interrupts
802 >     * the thread (in the hope that it may terminate later) and fails.
803 >     */
804 >    void awaitTermination(Thread t, long timeoutMillis) {
805 >        try {
806 >            t.join(timeoutMillis);
807 >        } catch (InterruptedException ie) {
808 >            threadUnexpectedException(ie);
809 >        } finally {
810 >            if (t.getState() != Thread.State.TERMINATED) {
811 >                t.interrupt();
812 >                fail("Test timed out");
813              }
814          }
815      }
816  
817 <    public class ShortInterruptedRunnable implements Runnable {
818 <        public void run() {
817 >    /**
818 >     * Waits for LONG_DELAY_MS milliseconds for the thread to
819 >     * terminate (using {@link Thread#join(long)}), else interrupts
820 >     * the thread (in the hope that it may terminate later) and fails.
821 >     */
822 >    void awaitTermination(Thread t) {
823 >        awaitTermination(t, LONG_DELAY_MS);
824 >    }
825 >
826 >    // Some convenient Runnable classes
827 >
828 >    public abstract class CheckedRunnable implements Runnable {
829 >        protected abstract void realRun() throws Throwable;
830 >
831 >        public final void run() {
832              try {
833 <                Thread.sleep(SHORT_DELAY_MS);
834 <                threadFail("should throw IE");
833 >                realRun();
834 >            } catch (Throwable t) {
835 >                threadUnexpectedException(t);
836              }
837 <            catch(InterruptedException success) {
837 >        }
838 >    }
839 >
840 >    public abstract class RunnableShouldThrow implements Runnable {
841 >        protected abstract void realRun() throws Throwable;
842 >
843 >        final Class<?> exceptionClass;
844 >
845 >        <T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) {
846 >            this.exceptionClass = exceptionClass;
847 >        }
848 >
849 >        public final void run() {
850 >            try {
851 >                realRun();
852 >                threadShouldThrow(exceptionClass.getSimpleName());
853 >            } catch (Throwable t) {
854 >                if (! exceptionClass.isInstance(t))
855 >                    threadUnexpectedException(t);
856              }
857          }
858      }
859  
860 <    public class SmallRunnable implements Runnable {
861 <        public void run() {
860 >    public abstract class ThreadShouldThrow extends Thread {
861 >        protected abstract void realRun() throws Throwable;
862 >
863 >        final Class<?> exceptionClass;
864 >
865 >        <T extends Throwable> ThreadShouldThrow(Class<T> exceptionClass) {
866 >            this.exceptionClass = exceptionClass;
867 >        }
868 >
869 >        public final void run() {
870              try {
871 <                Thread.sleep(SMALL_DELAY_MS);
871 >                realRun();
872 >                threadShouldThrow(exceptionClass.getSimpleName());
873 >            } catch (Throwable t) {
874 >                if (! exceptionClass.isInstance(t))
875 >                    threadUnexpectedException(t);
876              }
877 <            catch(Exception e) {
878 <                threadFail("unexpectedException");
877 >        }
878 >    }
879 >
880 >    public abstract class CheckedInterruptedRunnable implements Runnable {
881 >        protected abstract void realRun() throws Throwable;
882 >
883 >        public final void run() {
884 >            try {
885 >                realRun();
886 >                threadShouldThrow("InterruptedException");
887 >            } catch (InterruptedException success) {
888 >                threadAssertFalse(Thread.interrupted());
889 >            } catch (Throwable t) {
890 >                threadUnexpectedException(t);
891              }
892          }
893      }
894  
895 <    public class SmallCallable implements Callable {
896 <        public Object call() {
895 >    public abstract class CheckedCallable<T> implements Callable<T> {
896 >        protected abstract T realCall() throws Throwable;
897 >
898 >        public final T call() {
899              try {
900 <                Thread.sleep(SMALL_DELAY_MS);
900 >                return realCall();
901 >            } catch (Throwable t) {
902 >                threadUnexpectedException(t);
903 >                return null;
904              }
905 <            catch(Exception e) {
906 <                threadFail("unexpectedException");
905 >        }
906 >    }
907 >
908 >    public abstract class CheckedInterruptedCallable<T>
909 >        implements Callable<T> {
910 >        protected abstract T realCall() throws Throwable;
911 >
912 >        public final T call() {
913 >            try {
914 >                T result = realCall();
915 >                threadShouldThrow("InterruptedException");
916 >                return result;
917 >            } catch (InterruptedException success) {
918 >                threadAssertFalse(Thread.interrupted());
919 >            } catch (Throwable t) {
920 >                threadUnexpectedException(t);
921              }
922 +            return null;
923 +        }
924 +    }
925 +
926 +    public static class NoOpRunnable implements Runnable {
927 +        public void run() {}
928 +    }
929 +
930 +    public static class NoOpCallable implements Callable {
931 +        public Object call() { return Boolean.TRUE; }
932 +    }
933 +
934 +    public static final String TEST_STRING = "a test string";
935 +
936 +    public static class StringTask implements Callable<String> {
937 +        public String call() { return TEST_STRING; }
938 +    }
939 +
940 +    public Callable<String> latchAwaitingStringTask(final CountDownLatch latch) {
941 +        return new CheckedCallable<String>() {
942 +            protected String realCall() {
943 +                try {
944 +                    latch.await();
945 +                } catch (InterruptedException quittingTime) {}
946 +                return TEST_STRING;
947 +            }};
948 +    }
949 +
950 +    public Runnable awaiter(final CountDownLatch latch) {
951 +        return new CheckedRunnable() {
952 +            public void realRun() throws InterruptedException {
953 +                await(latch);
954 +            }};
955 +    }
956 +
957 +    public void await(CountDownLatch latch) {
958 +        try {
959 +            assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
960 +        } catch (Throwable t) {
961 +            threadUnexpectedException(t);
962 +        }
963 +    }
964 +
965 +    public void await(Semaphore semaphore) {
966 +        try {
967 +            assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
968 +        } catch (Throwable t) {
969 +            threadUnexpectedException(t);
970 +        }
971 +    }
972 +
973 + //     /**
974 + //      * Spin-waits up to LONG_DELAY_MS until flag becomes true.
975 + //      */
976 + //     public void await(AtomicBoolean flag) {
977 + //         await(flag, LONG_DELAY_MS);
978 + //     }
979 +
980 + //     /**
981 + //      * Spin-waits up to the specified timeout until flag becomes true.
982 + //      */
983 + //     public void await(AtomicBoolean flag, long timeoutMillis) {
984 + //         long startTime = System.nanoTime();
985 + //         while (!flag.get()) {
986 + //             if (millisElapsedSince(startTime) > timeoutMillis)
987 + //                 throw new AssertionFailedError("timed out");
988 + //             Thread.yield();
989 + //         }
990 + //     }
991 +
992 +    public static class NPETask implements Callable<String> {
993 +        public String call() { throw new NullPointerException(); }
994 +    }
995 +
996 +    public static class CallableOne implements Callable<Integer> {
997 +        public Integer call() { return one; }
998 +    }
999 +
1000 +    public class ShortRunnable extends CheckedRunnable {
1001 +        protected void realRun() throws Throwable {
1002 +            delay(SHORT_DELAY_MS);
1003 +        }
1004 +    }
1005 +
1006 +    public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
1007 +        protected void realRun() throws InterruptedException {
1008 +            delay(SHORT_DELAY_MS);
1009 +        }
1010 +    }
1011 +
1012 +    public class SmallRunnable extends CheckedRunnable {
1013 +        protected void realRun() throws Throwable {
1014 +            delay(SMALL_DELAY_MS);
1015 +        }
1016 +    }
1017 +
1018 +    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1019 +        protected void realRun() {
1020 +            try {
1021 +                delay(SMALL_DELAY_MS);
1022 +            } catch (InterruptedException ok) {}
1023 +        }
1024 +    }
1025 +
1026 +    public class SmallCallable extends CheckedCallable {
1027 +        protected Object realCall() throws InterruptedException {
1028 +            delay(SMALL_DELAY_MS);
1029              return Boolean.TRUE;
1030          }
1031      }
1032  
1033 <    public class SmallInterruptedRunnable implements Runnable {
1033 >    public class MediumRunnable extends CheckedRunnable {
1034 >        protected void realRun() throws Throwable {
1035 >            delay(MEDIUM_DELAY_MS);
1036 >        }
1037 >    }
1038 >
1039 >    public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
1040 >        protected void realRun() throws InterruptedException {
1041 >            delay(MEDIUM_DELAY_MS);
1042 >        }
1043 >    }
1044 >
1045 >    public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1046 >        return new CheckedRunnable() {
1047 >            protected void realRun() {
1048 >                try {
1049 >                    delay(timeoutMillis);
1050 >                } catch (InterruptedException ok) {}
1051 >            }};
1052 >    }
1053 >
1054 >    public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
1055 >        protected void realRun() {
1056 >            try {
1057 >                delay(MEDIUM_DELAY_MS);
1058 >            } catch (InterruptedException ok) {}
1059 >        }
1060 >    }
1061 >
1062 >    public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
1063 >        protected void realRun() {
1064 >            try {
1065 >                delay(LONG_DELAY_MS);
1066 >            } catch (InterruptedException ok) {}
1067 >        }
1068 >    }
1069 >
1070 >    /**
1071 >     * For use as ThreadFactory in constructors
1072 >     */
1073 >    public static class SimpleThreadFactory implements ThreadFactory {
1074 >        public Thread newThread(Runnable r) {
1075 >            return new Thread(r);
1076 >        }
1077 >    }
1078 >
1079 >    public interface TrackedRunnable extends Runnable {
1080 >        boolean isDone();
1081 >    }
1082 >
1083 >    public static TrackedRunnable trackedRunnable(final long timeoutMillis) {
1084 >        return new TrackedRunnable() {
1085 >                private volatile boolean done = false;
1086 >                public boolean isDone() { return done; }
1087 >                public void run() {
1088 >                    try {
1089 >                        delay(timeoutMillis);
1090 >                        done = true;
1091 >                    } catch (InterruptedException ok) {}
1092 >                }
1093 >            };
1094 >    }
1095 >
1096 >    public static class TrackedShortRunnable implements Runnable {
1097 >        public volatile boolean done = false;
1098          public void run() {
1099              try {
1100 <                Thread.sleep(SMALL_DELAY_MS);
1101 <                threadFail("should throw IE");
1102 <            }
216 <            catch(InterruptedException success) {
217 <            }
1100 >                delay(SHORT_DELAY_MS);
1101 >                done = true;
1102 >            } catch (InterruptedException ok) {}
1103          }
1104      }
1105  
1106 +    public static class TrackedSmallRunnable implements Runnable {
1107 +        public volatile boolean done = false;
1108 +        public void run() {
1109 +            try {
1110 +                delay(SMALL_DELAY_MS);
1111 +                done = true;
1112 +            } catch (InterruptedException ok) {}
1113 +        }
1114 +    }
1115  
1116 <    public class MediumRunnable implements Runnable {
1116 >    public static class TrackedMediumRunnable implements Runnable {
1117 >        public volatile boolean done = false;
1118          public void run() {
1119              try {
1120 <                Thread.sleep(MEDIUM_DELAY_MS);
1121 <            }
1122 <            catch(Exception e) {
228 <                threadFail("unexpectedException");
229 <            }
1120 >                delay(MEDIUM_DELAY_MS);
1121 >                done = true;
1122 >            } catch (InterruptedException ok) {}
1123          }
1124      }
1125  
1126 <    public class MediumInterruptedRunnable implements Runnable {
1126 >    public static class TrackedLongRunnable implements Runnable {
1127 >        public volatile boolean done = false;
1128          public void run() {
1129              try {
1130 <                Thread.sleep(MEDIUM_DELAY_MS);
1131 <                threadFail("should throw IE");
1132 <            }
239 <            catch(InterruptedException success) {
240 <            }
1130 >                delay(LONG_DELAY_MS);
1131 >                done = true;
1132 >            } catch (InterruptedException ok) {}
1133          }
1134      }
1135  
1136 <    public class MediumPossiblyInterruptedRunnable implements Runnable {
1136 >    public static class TrackedNoOpRunnable implements Runnable {
1137 >        public volatile boolean done = false;
1138          public void run() {
1139 +            done = true;
1140 +        }
1141 +    }
1142 +
1143 +    public static class TrackedCallable implements Callable {
1144 +        public volatile boolean done = false;
1145 +        public Object call() {
1146              try {
1147 <                Thread.sleep(MEDIUM_DELAY_MS);
1147 >                delay(SMALL_DELAY_MS);
1148 >                done = true;
1149 >            } catch (InterruptedException ok) {}
1150 >            return Boolean.TRUE;
1151 >        }
1152 >    }
1153 >
1154 >    /**
1155 >     * Analog of CheckedRunnable for RecursiveAction
1156 >     */
1157 >    public abstract class CheckedRecursiveAction extends RecursiveAction {
1158 >        protected abstract void realCompute() throws Throwable;
1159 >
1160 >        public final void compute() {
1161 >            try {
1162 >                realCompute();
1163 >            } catch (Throwable t) {
1164 >                threadUnexpectedException(t);
1165              }
1166 <            catch(InterruptedException success) {
1166 >        }
1167 >    }
1168 >
1169 >    /**
1170 >     * Analog of CheckedCallable for RecursiveTask
1171 >     */
1172 >    public abstract class CheckedRecursiveTask<T> extends RecursiveTask<T> {
1173 >        protected abstract T realCompute() throws Throwable;
1174 >
1175 >        public final T compute() {
1176 >            try {
1177 >                return realCompute();
1178 >            } catch (Throwable t) {
1179 >                threadUnexpectedException(t);
1180 >                return null;
1181              }
1182          }
1183      }
1184 <    
1184 >
1185 >    /**
1186 >     * For use as RejectedExecutionHandler in constructors
1187 >     */
1188 >    public static class NoOpREHandler implements RejectedExecutionHandler {
1189 >        public void rejectedExecution(Runnable r,
1190 >                                      ThreadPoolExecutor executor) {}
1191 >    }
1192 >
1193 >    /**
1194 >     * A CyclicBarrier that uses timed await and fails with
1195 >     * AssertionFailedErrors instead of throwing checked exceptions.
1196 >     */
1197 >    public class CheckedBarrier extends CyclicBarrier {
1198 >        public CheckedBarrier(int parties) { super(parties); }
1199 >
1200 >        public int await() {
1201 >            try {
1202 >                return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1203 >            } catch (TimeoutException e) {
1204 >                throw new AssertionFailedError("timed out");
1205 >            } catch (Exception e) {
1206 >                AssertionFailedError afe =
1207 >                    new AssertionFailedError("Unexpected exception: " + e);
1208 >                afe.initCause(e);
1209 >                throw afe;
1210 >            }
1211 >        }
1212 >    }
1213 >
1214 >    void checkEmpty(BlockingQueue q) {
1215 >        try {
1216 >            assertTrue(q.isEmpty());
1217 >            assertEquals(0, q.size());
1218 >            assertNull(q.peek());
1219 >            assertNull(q.poll());
1220 >            assertNull(q.poll(0, MILLISECONDS));
1221 >            assertEquals(q.toString(), "[]");
1222 >            assertTrue(Arrays.equals(q.toArray(), new Object[0]));
1223 >            assertFalse(q.iterator().hasNext());
1224 >            try {
1225 >                q.element();
1226 >                shouldThrow();
1227 >            } catch (NoSuchElementException success) {}
1228 >            try {
1229 >                q.iterator().next();
1230 >                shouldThrow();
1231 >            } catch (NoSuchElementException success) {}
1232 >            try {
1233 >                q.remove();
1234 >                shouldThrow();
1235 >            } catch (NoSuchElementException success) {}
1236 >        } catch (InterruptedException ie) {
1237 >            threadUnexpectedException(ie);
1238 >        }
1239 >    }
1240 >
1241 >    void assertSerialEquals(Object x, Object y) {
1242 >        assertTrue(Arrays.equals(serialBytes(x), serialBytes(y)));
1243 >    }
1244 >
1245 >    void assertNotSerialEquals(Object x, Object y) {
1246 >        assertFalse(Arrays.equals(serialBytes(x), serialBytes(y)));
1247 >    }
1248 >
1249 >    byte[] serialBytes(Object o) {
1250 >        try {
1251 >            ByteArrayOutputStream bos = new ByteArrayOutputStream();
1252 >            ObjectOutputStream oos = new ObjectOutputStream(bos);
1253 >            oos.writeObject(o);
1254 >            oos.flush();
1255 >            oos.close();
1256 >            return bos.toByteArray();
1257 >        } catch (Throwable t) {
1258 >            threadUnexpectedException(t);
1259 >            return new byte[0];
1260 >        }
1261 >    }
1262 >
1263 >    @SuppressWarnings("unchecked")
1264 >    <T> T serialClone(T o) {
1265 >        try {
1266 >            ObjectInputStream ois = new ObjectInputStream
1267 >                (new ByteArrayInputStream(serialBytes(o)));
1268 >            T clone = (T) ois.readObject();
1269 >            assertSame(o.getClass(), clone.getClass());
1270 >            return clone;
1271 >        } catch (Throwable t) {
1272 >            threadUnexpectedException(t);
1273 >            return null;
1274 >        }
1275 >    }
1276   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines