package org.junit.tests.experimental.rules;
   
   import static org.hamcrest.CoreMatchers.is;
   import static org.junit.Assert.assertThat;
   import static org.junit.Assert.fail;
   import static org.junit.Assume.assumeTrue;
   import static org.junit.experimental.results.PrintableResult.testResult;
   import static org.junit.experimental.results.ResultMatchers.failureCountIs;
   import static org.junit.experimental.results.ResultMatchers.hasFailureContaining;
  import static org.junit.runner.JUnitCore.runClasses;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.experimental.results.PrintableResult;
  import org.junit.internal.AssumptionViolatedException;
  import org.junit.rules.TestRule;
  import org.junit.rules.TestWatcher;
  import org.junit.runner.Description;
  
  public class TestWatcherTest {
      public static class ViolatedAssumptionTest {
          private static StringBuilder watchedLog = new StringBuilder();
  
          @Rule
          public TestRule watcher = new LoggingTestWatcher(watchedLog);
  
          @Test
          public void succeeds() {
              assumeTrue(false);
          }
      }
  
      @Test
      public void neitherLogSuccessNorFailedForViolatedAssumption() {
          ViolatedAssumptionTest.watchedLog = new StringBuilder();
          runClasses(ViolatedAssumptionTest.class);
          assertThat(ViolatedAssumptionTest.watchedLog.toString(),
                  is("starting skipped finished "));
      }
  
      public static class InternalViolatedAssumptionTest {
          private static StringBuilder watchedLog = new StringBuilder();
  
          @Rule
          public TestRule watcher = new TestWatcher() {
              @Override
              protected void starting(Description description) {
                  watchedLog.append("starting ");
              }
  
              @Override
              protected void finished(Description description) {
                  watchedLog.append("finished ");
              }
  
              protected void skipped(AssumptionViolatedException e, Description description) {
                  watchedLog.append("skipped ");
              }
          };
  
          @Test
          public void succeeds() {
              throw new AssumptionViolatedException("don't run");
          }
      }
  
      @Test
      public void internalViolatedAssumption() {
          InternalViolatedAssumptionTest.watchedLog = new StringBuilder();
          runClasses(InternalViolatedAssumptionTest.class);
          assertThat(InternalViolatedAssumptionTest.watchedLog.toString(),
                  is("starting skipped finished "));
      }
  
      public static class TestWatcherSkippedThrowsExceptionTest {
          @Rule
          public TestRule watcher = new TestWatcher() {
              @Override
              protected void skipped(AssumptionViolatedException e, Description description) {
                  throw new RuntimeException("watcher failure");
              }
          };
  
          @Test
          public void fails() {
              throw new AssumptionViolatedException("test failure");
          }
      }
  
      @Test
      public void testWatcherSkippedThrowsException() {
          PrintableResult result = testResult(TestWatcherSkippedThrowsExceptionTest.class);
          assertThat(result, failureCountIs(2));
          assertThat(result, hasFailureContaining("test failure"));
          assertThat(result, hasFailureContaining("watcher failure"));
      }
  
      public static class FailingTest {
          private static StringBuilder watchedLog = new StringBuilder();
  
         @Rule
         public TestRule watcher = new LoggingTestWatcher(watchedLog);
 
         @Test
         public void succeeds() {
             fail();
         }
     }
 
     @Test
     public void logFailingTest() {
         FailingTest.watchedLog = new StringBuilder();
         runClasses(FailingTest.class);
         assertThat(FailingTest.watchedLog.toString(),
                 is("starting failed finished "));
     }
 
     public static class TestWatcherFailedThrowsExceptionTest {
         @Rule
         public TestRule watcher = new TestWatcher() {
             @Override
             protected void failed(Throwable e, Description description) {
                 throw new RuntimeException("watcher failure");
             }
         };
 
         @Test
         public void fails() {
             throw new IllegalArgumentException("test failure");
         }
     }
 
     @Test
     public void testWatcherFailedThrowsException() {
         PrintableResult result = testResult(TestWatcherFailedThrowsExceptionTest.class);
         assertThat(result, failureCountIs(2));
         assertThat(result, hasFailureContaining("test failure"));
         assertThat(result, hasFailureContaining("watcher failure"));
     }
 
     public static class TestWatcherStartingThrowsExceptionTest {
         @Rule
         public TestRule watcher = new TestWatcher() {
             @Override
             protected void starting(Description description) {
                 throw new RuntimeException("watcher failure");
             }
         };
 
         @Test
         public void fails() {
             throw new IllegalArgumentException("test failure");
         }
     }
 
     @Test
     public void testWatcherStartingThrowsException() {
         PrintableResult result = testResult(TestWatcherStartingThrowsExceptionTest.class);
         assertThat(result, failureCountIs(2));
         assertThat(result, hasFailureContaining("test failure"));
         assertThat(result, hasFailureContaining("watcher failure"));
     }
 
     public static class TestWatcherFailedAndFinishedThrowsExceptionTest {
         @Rule
         public TestRule watcher = new TestWatcher() {
             @Override
             protected void failed(Throwable e, Description description) {
                 throw new RuntimeException("watcher failed failure");
             }
 
             @Override
             protected void finished(Description description) {
                 throw new RuntimeException("watcher finished failure");
             }
         };
 
         @Test
         public void fails() {
             throw new IllegalArgumentException("test failure");
         }
     }
 
     @Test
     public void testWatcherFailedAndFinishedThrowsException() {
         PrintableResult result = testResult(TestWatcherFailedAndFinishedThrowsExceptionTest.class);
         assertThat(result, failureCountIs(3));
         assertThat(result, hasFailureContaining("test failure"));
         assertThat(result, hasFailureContaining("watcher failed failure"));
         assertThat(result, hasFailureContaining("watcher finished failure"));
     }
 }