package org.junit.tests.internal.runners.statements;
   
   import static java.lang.Long.MAX_VALUE;
   import static java.lang.Math.atan;
   import static java.lang.System.currentTimeMillis;
   import static java.lang.Thread.sleep;
   import static org.hamcrest.core.Is.is;
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.util.concurrent.TimeUnit;
  
  import org.junit.Ignore;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.internal.runners.statements.FailOnTimeout;
  import org.junit.rules.ExpectedException;
  import org.junit.runners.model.Statement;
  import org.junit.runners.model.TestTimedOutException;
  
  /**
   * @author Asaf Ary, Stefan Birkner
   */
  public class FailOnTimeoutTest {
      private static final int TIMEOUT = 100;
      private static final int DURATION_THAT_EXCEEDS_TIMEOUT = 60 * 60 * 1000; //1 hour
  
      @Rule
      public final ExpectedException thrown = ExpectedException.none();
  
      private final TestStatement statement = new TestStatement();
  
      private final FailOnTimeout failOnTimeout = new FailOnTimeout(statement,
              TIMEOUT);
  
      @Test
      public void throwsTestTimedOutException() throws Throwable {
          thrown.expect(TestTimedOutException.class);
          evaluateWithWaitDuration(DURATION_THAT_EXCEEDS_TIMEOUT);
      }
  
      @Test
      public void throwExceptionWithNiceMessageOnTimeout() throws Throwable {
          thrown.expectMessage("test timed out after 100 milliseconds");
          evaluateWithWaitDuration(DURATION_THAT_EXCEEDS_TIMEOUT);
      }
  
      @Test
      public void sendUpExceptionThrownByStatement() throws Throwable {
          RuntimeException exception = new RuntimeException();
          thrown.expect(is(exception));
          evaluateWithException(exception);
      }
  
      @Test
      public void throwExceptionIfTheSecondCallToEvaluateNeedsTooMuchTime()
              throws Throwable {
          thrown.expect(TestTimedOutException.class);
          evaluateWithWaitDuration(0);
          evaluateWithWaitDuration(DURATION_THAT_EXCEEDS_TIMEOUT);
      }
  
      @Test
      public void throwTimeoutExceptionOnSecondCallAlthoughFirstCallThrowsException()
              throws Throwable {
          thrown.expectMessage("test timed out after 100 milliseconds");
          try {
              evaluateWithException(new RuntimeException());
          } catch (Throwable expected) {
          }
          evaluateWithWaitDuration(DURATION_THAT_EXCEEDS_TIMEOUT);
      }
  
      @Test
      public void throwsExceptionWithTimeoutValueAndTimeUnitSet()
              throws Throwable {
          try {
              evaluateWithWaitDuration(DURATION_THAT_EXCEEDS_TIMEOUT);
              fail("No exception was thrown when test timed out");
          } catch (TestTimedOutException e) {
              assertEquals(TIMEOUT, e.getTimeout());
              assertEquals(TimeUnit.MILLISECONDS, e.getTimeUnit());
          }
      }
  
      private void evaluateWithException(Exception exception) throws Throwable {
          statement.nextException = exception;
          statement.waitDuration = 0;
          failOnTimeout.evaluate();
      }
  
      private void evaluateWithWaitDuration(int waitDuration) throws Throwable {
          statement.nextException = null;
          statement.waitDuration = waitDuration;
          failOnTimeout.evaluate();
      }
  
     private static final class TestStatement extends Statement {
         int waitDuration;
 
         Exception nextException;
 
         @Override
         public void evaluate() throws Throwable {
             sleep(waitDuration);
             if (nextException != null) {
                 throw nextException;
             }
         }
     }
 
     @Test
     public void stopEndlessStatement() throws Throwable {
         InfiniteLoopStatement infiniteLoop = new InfiniteLoopStatement();
         FailOnTimeout infiniteLoopTimeout = new FailOnTimeout(infiniteLoop,
                 TIMEOUT);
         try {
             infiniteLoopTimeout.evaluate();
         } catch (Exception timeoutException) {
             sleep(20); // time to interrupt the thread
             int firstCount = InfiniteLoopStatement.COUNT;
             sleep(20); // time to increment the count
             assertTrue("Thread has not been stopped.",
                     firstCount == InfiniteLoopStatement.COUNT);
         }
     }
 
     private static final class InfiniteLoopStatement extends Statement {
         private static int COUNT = 0;
 
         @Override
         public void evaluate() throws Throwable {
             while (true) {
                 sleep(10); // sleep in order to enable interrupting thread
                 ++COUNT;
             }
         }
     }
 
     @Test
     public void stackTraceContainsRealCauseOfTimeout() throws Throwable {
         StuckStatement stuck = new StuckStatement();
         FailOnTimeout stuckTimeout = new FailOnTimeout(stuck, TIMEOUT);
         try {
             stuckTimeout.evaluate();
             // We must not get here, we expect a timeout exception
             fail("Expected timeout exception");
         } catch (Exception timeoutException) {
             StackTraceElement[] stackTrace = timeoutException.getStackTrace();
             boolean stackTraceContainsTheRealCauseOfTheTimeout = false;
             boolean stackTraceContainsOtherThanTheRealCauseOfTheTimeout = false;
             for (StackTraceElement element : stackTrace) {
                 String methodName = element.getMethodName();
                 if ("theRealCauseOfTheTimeout".equals(methodName)) {
                     stackTraceContainsTheRealCauseOfTheTimeout = true;
                 }
                 if ("notTheRealCauseOfTheTimeout".equals(methodName)) {
                     stackTraceContainsOtherThanTheRealCauseOfTheTimeout = true;
                 }
             }
             assertTrue(
                     "Stack trace does not contain the real cause of the timeout",
                     stackTraceContainsTheRealCauseOfTheTimeout);
             assertFalse(
                     "Stack trace contains other than the real cause of the timeout, which can be very misleading",
                     stackTraceContainsOtherThanTheRealCauseOfTheTimeout);
         }
     }
 
     private static final class StuckStatement extends Statement {
 
         @Override
         public void evaluate() throws Throwable {
             try {
                 // Must show up in stack trace
                 theRealCauseOfTheTimeout();
             } catch (InterruptedException e) {
             } finally {
                 // Must _not_ show up in stack trace
                 notTheRealCauseOfTheTimeout();
             }
         }
 
         private void theRealCauseOfTheTimeout() throws InterruptedException {
             sleep(MAX_VALUE);
         }
 
         private void notTheRealCauseOfTheTimeout() {
             for (long now = currentTimeMillis(), eta = now + 1000L; now < eta; now = currentTimeMillis()) {
                 // Doesn't matter, just pretend to be busy
                 atan(now);
             }
         }
     }
 }