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());
     }
 }