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.266 by jsr166, Sat Sep 7 17:40:05 2019 UTC vs.
Revision 1.271 by jsr166, Sat Feb 1 18:52:17 2020 UTC

# Line 49 | Line 49 | import java.io.ByteArrayOutputStream;
49   import java.io.ObjectInputStream;
50   import java.io.ObjectOutputStream;
51   import java.lang.management.ManagementFactory;
52 + import java.lang.management.LockInfo;
53   import java.lang.management.ThreadInfo;
54   import java.lang.management.ThreadMXBean;
55   import java.lang.reflect.Constructor;
# Line 243 | Line 244 | public class JSR166TestCase extends Test
244          }
245      }
246  
247 +    private static final ThreadMXBean THREAD_MXBEAN
248 +        = ManagementFactory.getThreadMXBean();
249 +
250      /**
251       * The scaling factor to apply to standard delays used in tests.
252       * May be initialized from any of:
# Line 354 | Line 358 | public class JSR166TestCase extends Test
358              // Never report first run of any test; treat it as a
359              // warmup run, notably to trigger all needed classloading,
360              if (i > 0)
361 <                System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
361 >                System.out.printf("%s: %d%n", toString(), elapsedMillis);
362          }
363      }
364  
# Line 700 | Line 704 | public class JSR166TestCase extends Test
704      /**
705       * Returns a random element from given choices.
706       */
707 +    <T> T chooseRandomly(List<T> choices) {
708 +        return choices.get(ThreadLocalRandom.current().nextInt(choices.size()));
709 +    }
710 +
711 +    /**
712 +     * Returns a random element from given choices.
713 +     */
714      <T> T chooseRandomly(T... choices) {
715          return choices[ThreadLocalRandom.current().nextInt(choices.length)];
716      }
# Line 1130 | Line 1141 | public class JSR166TestCase extends Test
1141              }
1142          }
1143  
1133 –        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
1144          System.err.println("------ stacktrace dump start ------");
1145 <        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true))
1145 >        for (ThreadInfo info : THREAD_MXBEAN.dumpAllThreads(true, true))
1146              if (threadOfInterest(info))
1147                  System.err.print(info);
1148          System.err.println("------ stacktrace dump end ------");
# Line 1161 | Line 1171 | public class JSR166TestCase extends Test
1171      }
1172  
1173      /**
1174 +     * Returns the thread's blocker's class name, if any, else null.
1175 +     */
1176 +    String blockerClassName(Thread thread) {
1177 +        ThreadInfo threadInfo; LockInfo lockInfo;
1178 +        if ((threadInfo = THREAD_MXBEAN.getThreadInfo(thread.getId(), 0)) != null
1179 +            && (lockInfo = threadInfo.getLockInfo()) != null)
1180 +            return lockInfo.getClassName();
1181 +        return null;
1182 +    }
1183 +
1184 +    /**
1185       * Checks that future.get times out, with the default timeout of
1186       * {@code timeoutMillis()}.
1187       */
# Line 1179 | Line 1200 | public class JSR166TestCase extends Test
1200          } catch (TimeoutException success) {
1201          } catch (Exception fail) {
1202              threadUnexpectedException(fail);
1203 <        } finally { future.cancel(true); }
1203 >        }
1204          assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
1205 +        assertFalse(future.isDone());
1206      }
1207  
1208      /**
# Line 1459 | Line 1481 | public class JSR166TestCase extends Test
1481      }
1482  
1483      /**
1484 +     * Returns a new started daemon Thread running the given action,
1485 +     * wrapped in a CheckedRunnable.
1486 +     */
1487 +    Thread newStartedThread(Action action) {
1488 +        return newStartedThread(checkedRunnable(action));
1489 +    }
1490 +
1491 +    /**
1492       * Waits for the specified time (in milliseconds) for the thread
1493       * to terminate (using {@link Thread#join(long)}), else interrupts
1494       * the thread (in the hope that it may terminate later) and fails.
# Line 1505 | Line 1535 | public class JSR166TestCase extends Test
1535          }
1536      }
1537  
1538 +    Runnable checkedRunnable(Action action) {
1539 +        return new CheckedRunnable() {
1540 +            public void realRun() throws Throwable {
1541 +                action.run();
1542 +            }};
1543 +    }
1544 +
1545      public abstract class ThreadShouldThrow extends Thread {
1546          protected abstract void realRun() throws Throwable;
1547  
# Line 1743 | Line 1780 | public class JSR166TestCase extends Test
1780  
1781          public int await() {
1782              try {
1783 <                return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1783 >                return super.await(LONGER_DELAY_MS, MILLISECONDS);
1784              } catch (TimeoutException timedOut) {
1785                  throw new AssertionError("timed out");
1786              } catch (Exception fail) {

Diff Legend

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