Source code
package org.junit.rules;
import org.junit.internal.AssumptionViolatedException;
import org.junit.runner.Description;
import java.util.concurrent.TimeUnit;
/**
* The Stopwatch Rule notifies one of its own protected methods of the time spent by a test.<p/>
* Override them to get the time in nanoseconds. For example, this class will keep logging the
* time spent by each passed, failed, skipped, and finished test:
*
* <pre>
* public static class StopwatchTest {
* private static final Logger logger= Logger.getLogger("");
*
* private static void logInfo(String testName, String status, long nanos) {
* logger.info(String.format("Test %s %s, spent %d microseconds",
* testName, status, Stopwatch.toMicros(nanos)));
* }
*
* @Rule
* public Stopwatch stopwatch= new Stopwatch() {
* @Override
* protected void succeeded(long nanos, Description description) {
* logInfo(description.getMethodName(), "succeeded", nanos);
* }
*
* @Override
* protected void failed(long nanos, Throwable e, Description description) {
* logInfo(description.getMethodName(), "failed", nanos);
* }
*
* @Override
* protected void skipped(long nanos, AssumptionViolatedException e, Description description) {
* logInfo(description.getMethodName(), "skipped", nanos);
* }
*
* @Override
* protected void finished(long nanos, Description description) {
* logInfo(description.getMethodName(), "finished", nanos);
* }
* };
*
* @Test
* public void succeeds() {
* }
*
* @Test
* public void fails() {
* fail();
* }
*
* @Test
* public void skips() {
* assumeTrue(false);
* }
* }
* </pre>
*
* An example to assert runtime:
* <pre>
* @Test
* public void performanceTest() throws InterruptedException {
* long delta= 30;
* Thread.sleep(300L);
* assertEquals(300d, stopwatch.runtime(MILLISECONDS), delta);
* Thread.sleep(500L);
* assertEquals(800d, stopwatch.runtime(MILLISECONDS), delta);
* }
* </pre>
*
* @author tibor17
* @since 4.12
*/
public class Stopwatch extends TestWatcher {
private long fStartNanos;
private long fEndNanos;
/**
* @param unit time unit for returned runtime
* @return runtime measured during the test
*/
public long runtime(TimeUnit unit) {
return unit.convert(currentNanoTime() - fStartNanos, TimeUnit.NANOSECONDS);
}
/**
* Invoked when a test succeeds
*/
protected void succeeded(long nanos, Description description) {
}
/**
* Invoked when a test fails
*/
protected void failed(long nanos, Throwable e, Description description) {
}
/**
* Invoked when a test is skipped due to a failed assumption.
*/
protected void skipped(long nanos, AssumptionViolatedException e, Description description) {
}
/**
* Invoked when a test method finishes (whether passing or failing)
*/
protected void finished(long nanos, Description description) {
}
/**
* @param nanos time in nanoseconds
* @return time converted to microseconds
*/
public static long toMicros(long nanos) {
return TimeUnit.NANOSECONDS.toMicros(nanos);
}
/**
* @param nanos time in nanoseconds
* @return time converted to milliseconds
*/
public static long toMillis(long nanos) {
return TimeUnit.NANOSECONDS.toMillis(nanos);
}
/**
* @param nanos time in nanoseconds
* @return time converted to seconds
*/
public static long toSeconds(long nanos) {
return TimeUnit.NANOSECONDS.toSeconds(nanos);
}
private long getNanos() {
return fEndNanos - fStartNanos;
}
private void starting() {
fStartNanos= currentNanoTime();
}
private void stopping() {
fEndNanos= currentNanoTime();
}
private long currentNanoTime() {
return System.nanoTime();
}
@Override final protected void succeeded(Description description) {
stopping();
succeeded(getNanos(), description);
}
@Override final protected void failed(Throwable e, Description description) {
stopping();
failed(getNanos(), e, description);
}
@Override final protected void skipped(AssumptionViolatedException e, Description description) {
stopping();
skipped(getNanos(), e, description);
}
@Override final protected void starting(Description description) {
starting();
}
@Override final protected void finished(Description description) {
finished(getNanos(), description);
}
}