package org.junit.rules;
import java.util.concurrent.TimeUnit;
import org.junit.AssumptionViolatedException;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Stopwatch;
import org.junit.runner.Description;
import org.junit.runner.JUnitCore;
import org.junit.runner.Request;
import org.junit.runner.Result;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assume.assumeTrue;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assert.assertNotEquals;
/**
* @author tibor17
* @since 4.12
*/
public class StopwatchTest {
private static enum TestStatus { SUCCEEDED, FAILED, SKIPPED }
private static Record record;
private static Record finishedRecord;
private static long fakeTimeNanos = 1234;
private static class Record {
final long duration;
final String name;
final TestStatus status;
Record() {
this(0, null, null);
}
Record(long duration, Description description) {
this(duration, null, description);
}
Record(long duration, TestStatus status, Description description) {
this.duration = duration;
this.status = status;
this.name = description == null ? null : description.getMethodName();
}
}
public static abstract class AbstractStopwatchTest {
/**
* Fake implementation of {@link Stopwatch.Clock} that increments the time
* every time it is asked.
*/
private final Stopwatch.Clock fakeClock = new Stopwatch.Clock() {
@Override
public long nanoTime() {
return fakeTimeNanos++;
}
};
protected final Stopwatch stopwatch = new Stopwatch(fakeClock) {
@Override
protected void succeeded(long nanos, Description description) {
StopwatchTest.record = new Record(nanos, TestStatus.SUCCEEDED, description);
simulateTimePassing(1);
}
@Override
protected void failed(long nanos, Throwable e, Description description) {
StopwatchTest.record = new Record(nanos, TestStatus.FAILED, description);
simulateTimePassing(1);
}
@Override
protected void skipped(long nanos, AssumptionViolatedException e, Description description) {
StopwatchTest.record = new Record(nanos, TestStatus.SKIPPED, description);
simulateTimePassing(1);
}
@Override
protected void finished(long nanos, Description description) {
StopwatchTest.finishedRecord = new Record(nanos, description);
}
};
private final TestWatcher watcher = new TestWatcher() {
@Override
protected void finished(Description description) {
afterStopwatchRule();
}
};
@Rule
public final RuleChain chain = RuleChain
.outerRule(watcher)
.around(stopwatch);
protected void afterStopwatchRule() {
}
}
public static class SuccessfulTest extends AbstractStopwatchTest {
@Test
public void successfulTest() {
}
}
public static class FailedTest extends AbstractStopwatchTest {
@Test
public void failedTest() {
fail();
}
}
public static class SkippedTest extends AbstractStopwatchTest {
@Test
public void skippedTest() {
assumeTrue(false);
}
}
public static class DurationDuringTestTest extends AbstractStopwatchTest {
@Test
public void duration() {
simulateTimePassing(300L);
assertEquals(300L, stopwatch.runtime(MILLISECONDS));
simulateTimePassing(500L);
assertEquals(800L, stopwatch.runtime(MILLISECONDS));
}
}
public static class DurationAfterTestTest extends AbstractStopwatchTest {
@Test
public void duration() {
simulateTimePassing(300L);
assertEquals(300L, stopwatch.runtime(MILLISECONDS));
}
@Override
protected void afterStopwatchRule() {
assertEquals(300L, stopwatch.runtime(MILLISECONDS));
simulateTimePassing(500L);
assertEquals(300L, stopwatch.runtime(MILLISECONDS));
}
}
@Before
public void init() {
record = new Record();
finishedRecord = new Record();
simulateTimePassing(1L);
}
private static Result runTest(Class<?> test) {
simulateTimePassing(1L);
JUnitCore junitCore = new JUnitCore();
return junitCore.run(Request.aClass(test).getRunner());
}
private static void simulateTimePassing(long millis) {
fakeTimeNanos += TimeUnit.MILLISECONDS.toNanos(millis);
}
@Test
public void succeeded() {
Result result = runTest(SuccessfulTest.class);
assertEquals(0, result.getFailureCount());
assertThat(record.name, is("successfulTest"));
assertThat(record.name, is(finishedRecord.name));
assertThat(record.status, is(TestStatus.SUCCEEDED));
assertTrue("timeSpent > 0", record.duration > 0);
assertThat(record.duration, is(finishedRecord.duration));
}
@Test
public void failed() {
Result result = runTest(FailedTest.class);
assertEquals(1, result.getFailureCount());
assertThat(record.name, is("failedTest"));
assertThat(record.name, is(finishedRecord.name));
assertThat(record.status, is(TestStatus.FAILED));
assertTrue("timeSpent > 0", record.duration > 0);
assertThat(record.duration, is(finishedRecord.duration));
}
@Test
public void skipped() {
Result result = runTest(SkippedTest.class);
assertEquals(0, result.getFailureCount());
assertThat(record.name, is("skippedTest"));
assertThat(record.name, is(finishedRecord.name));
assertThat(record.status, is(TestStatus.SKIPPED));
assertTrue("timeSpent > 0", record.duration > 0);
assertThat(record.duration, is(finishedRecord.duration));
}
@Test
public void runtimeDuringTestShouldReturnTimeSinceStart() {
Result result = runTest(DurationDuringTestTest.class);
assertTrue(result.wasSuccessful());
}
@Test
public void runtimeAfterTestShouldReturnRunDuration() {
Result result = runTest(DurationAfterTestTest.class);
assertTrue(result.wasSuccessful());
}
}