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.222 by jsr166, Fri May 12 18:12:51 2017 UTC vs.
Revision 1.231 by jsr166, Mon May 15 17:02:46 2017 UTC

# Line 658 | Line 658 | public class JSR166TestCase extends Test
658          LONG_DELAY_MS   = SHORT_DELAY_MS * 200;
659      }
660  
661 +    private static final long TIMEOUT_DELAY_MS
662 +        = (long) (12.0 * Math.cbrt(delayFactor));
663 +
664      /**
665 <     * Returns a timeout in milliseconds to be used in tests that
666 <     * verify that operations block or time out.
665 >     * Returns a timeout in milliseconds to be used in tests that verify
666 >     * that operations block or time out.  We want this to be longer
667 >     * than the OS scheduling quantum, but not too long, so don't scale
668 >     * linearly with delayFactor; we use "crazy" cube root instead.
669       */
670 <    long timeoutMillis() {
671 <        return SHORT_DELAY_MS / 4;
670 >    static long timeoutMillis() {
671 >        return TIMEOUT_DELAY_MS;
672      }
673  
674      /**
# Line 1058 | Line 1063 | public class JSR166TestCase extends Test
1063      }
1064  
1065      /**
1066 +     * Checks that thread eventually enters the expected blocked thread state.
1067 +     */
1068 +    void assertThreadBlocks(Thread thread, Thread.State expected) {
1069 +        // always sleep at least 1 ms, with high probability avoiding
1070 +        // transitory states
1071 +        for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) {
1072 +            try { delay(1); }
1073 +            catch (InterruptedException fail) {
1074 +                fail("Unexpected InterruptedException");
1075 +            }
1076 +            Thread.State s = thread.getState();
1077 +            if (s == expected)
1078 +                return;
1079 +            else if (s == Thread.State.TERMINATED)
1080 +                fail("Unexpected thread termination");
1081 +        }
1082 +        fail("timed out waiting for thread to enter thread state " + expected);
1083 +    }
1084 +
1085 +    /**
1086       * Checks that thread does not terminate within the default
1087       * millisecond delay of {@code timeoutMillis()}.
1088 +     * TODO: REMOVEME
1089       */
1090      void assertThreadStaysAlive(Thread thread) {
1091          assertThreadStaysAlive(thread, timeoutMillis());
# Line 1067 | Line 1093 | public class JSR166TestCase extends Test
1093  
1094      /**
1095       * Checks that thread does not terminate within the given millisecond delay.
1096 +     * TODO: REMOVEME
1097       */
1098      void assertThreadStaysAlive(Thread thread, long millis) {
1099          try {
# Line 1081 | Line 1108 | public class JSR166TestCase extends Test
1108      /**
1109       * Checks that the threads do not terminate within the default
1110       * millisecond delay of {@code timeoutMillis()}.
1111 +     * TODO: REMOVEME
1112       */
1113      void assertThreadsStayAlive(Thread... threads) {
1114          assertThreadsStayAlive(timeoutMillis(), threads);
# Line 1088 | Line 1116 | public class JSR166TestCase extends Test
1116  
1117      /**
1118       * Checks that the threads do not terminate within the given millisecond delay.
1119 +     * TODO: REMOVEME
1120       */
1121      void assertThreadsStayAlive(long millis, Thread... threads) {
1122          try {
# Line 1610 | Line 1639 | public class JSR166TestCase extends Test
1639          } catch (Throwable fail) {
1640              threadUnexpectedException(fail);
1641          }
1642 +    }
1643 +
1644 +    public void await(CyclicBarrier barrier) {
1645 +        try {
1646 +            barrier.await(LONG_DELAY_MS, MILLISECONDS);
1647 +        } catch (Throwable fail) {
1648 +            threadUnexpectedException(fail);
1649 +        }
1650      }
1651  
1652   //     /**

Diff Legend

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