package org.junit.tests.running.classes;
   
   import static org.hamcrest.CoreMatchers.equalTo;
   import static org.hamcrest.CoreMatchers.is;
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertThat;
   
   import java.util.List;
   
  import org.hamcrest.Matcher;
  import org.hamcrest.TypeSafeMatcher;
  import org.junit.Assert;
  import org.junit.BeforeClass;
  import org.junit.Ignore;
  import org.junit.Test;
  import org.junit.internal.AssumptionViolatedException;
  import org.junit.runner.Description;
  import org.junit.runner.JUnitCore;
  import org.junit.runner.Request;
  import org.junit.runner.Result;
  import org.junit.runner.manipulation.Filter;
  import org.junit.runner.notification.Failure;
  import org.junit.runner.notification.RunListener;
  import org.junit.runner.notification.RunNotifier;
  import org.junit.runners.BlockJUnit4ClassRunner;
  import org.junit.runners.ParentRunner;
  import org.junit.runners.model.InitializationError;
  import org.junit.runners.model.RunnerScheduler;
  import org.junit.tests.experimental.rules.RuleMemberValidatorTest.TestWithNonStaticClassRule;
  import org.junit.tests.experimental.rules.RuleMemberValidatorTest.TestWithProtectedClassRule;
  
  public class ParentRunnerTest {
      public static String log = "";
  
      public static class FruitTest {
          @Test
          public void apple() {
              log += "apple ";
          }
  
          @Test
          public void /* must hash-sort after "apple" */Banana() {
              log += "banana ";
          }
      }
  
      @Test
      public void useChildHarvester() throws InitializationError {
          log = "";
          ParentRunner<?> runner = new BlockJUnit4ClassRunner(FruitTest.class);
          runner.setScheduler(new RunnerScheduler() {
              public void schedule(Runnable childStatement) {
                  log += "before ";
                  childStatement.run();
                  log += "after ";
              }
  
              public void finished() {
                  log += "afterAll ";
              }
          });
  
          runner.run(new RunNotifier());
          assertEquals("before apple after before banana after afterAll ", log);
      }
  
      @Test
      public void testMultipleFilters() throws Exception {
          JUnitCore junitCore = new JUnitCore();
          Request request = Request.aClass(ExampleTest.class);
          Request requestFiltered = request.filterWith(new Exclude("test1"));
          Request requestFilteredFiltered = requestFiltered
                  .filterWith(new Exclude("test2"));
          Result result = junitCore.run(requestFilteredFiltered);
          assertThat(result.getFailures(), isEmpty());
          assertEquals(1, result.getRunCount());
      }
  
      private Matcher<List<?>> isEmpty() {
          return new TypeSafeMatcher<List<?>>() {
              public void describeTo(org.hamcrest.Description description) {
                  description.appendText("is empty");
              }
  
              @Override
              public boolean matchesSafely(List<?> item) {
                  return item.size() == 0;
              }
          };
      }
  
      private static class Exclude extends Filter {
          private final String methodName;
  
          public Exclude(String methodName) {
              this.methodName = methodName;
          }
  
          @Override
         public boolean shouldRun(Description description) {
             return !description.getMethodName().equals(methodName);
         }
 
         @Override
         public String describe() {
             return "filter method name: " + methodName;
         }
     }
 
     public static class ExampleTest {
         @Test
         public void test1() throws Exception {
         }
 
         @Test
         public void test2() throws Exception {
         }
 
         @Test
         public void test3() throws Exception {
         }
     }
 
     @Test
     public void failWithHelpfulMessageForProtectedClassRule() {
         assertClassHasFailureMessage(TestWithProtectedClassRule.class,
                 "The @ClassRule 'temporaryFolder' must be public.");
     }
 
     @Test
     public void failWithHelpfulMessageForNonStaticClassRule() {
         assertClassHasFailureMessage(TestWithNonStaticClassRule.class,
                 "The @ClassRule 'temporaryFolder' must be static.");
     }
 
     static class NonPublicTestClass {
         public NonPublicTestClass() {
         }
     }
 
     @Test
     public void cannotBeCreatedWithNonPublicTestClass() {
         assertClassHasFailureMessage(
                 NonPublicTestClass.class,
                 "The class org.junit.tests.running.classes.ParentRunnerTest$NonPublicTestClass is not public.");
     }
 
     private void assertClassHasFailureMessage(Class<?> klass, String message) {
         JUnitCore junitCore = new JUnitCore();
         Request request = Request.aClass(klass);
         Result result = junitCore.run(request);
         assertThat(result.getFailureCount(), is(2)); //the second failure is no runnable methods
         assertThat(result.getFailures().get(0).getMessage(),
                 is(equalTo(message)));
     }
 
     public static class AssertionErrorAtParentLevelTest {
         @BeforeClass
         public static void beforeClass() throws Throwable {
             throw new AssertionError("Thrown from @BeforeClass");
         }
 
         @Test
         public void test() {}
     }
 
     @Test
     public void assertionErrorAtParentLevelTest() throws InitializationError {
         CountingRunListener countingRunListener = runTestWithParentRunner(AssertionErrorAtParentLevelTest.class);
         Assert.assertEquals(0, countingRunListener.testStarted);
         Assert.assertEquals(0, countingRunListener.testFinished);
         Assert.assertEquals(1, countingRunListener.testFailure);
         Assert.assertEquals(0, countingRunListener.testAssumptionFailure);
         Assert.assertEquals(0, countingRunListener.testIgnored);
     }
 
     public static class AssumptionViolatedAtParentLevelTest {
         @BeforeClass
         public static void beforeClass() {
             throw new AssumptionViolatedException("Thrown from @BeforeClass");
         }
 
         @Test
         public void test() {}
     }
 
     @Test
     public void assumptionViolatedAtParentLevel() throws InitializationError {
         CountingRunListener countingRunListener = runTestWithParentRunner(AssumptionViolatedAtParentLevelTest.class);
         Assert.assertEquals(0, countingRunListener.testStarted);
         Assert.assertEquals(0, countingRunListener.testFinished);
         Assert.assertEquals(0, countingRunListener.testFailure);
         Assert.assertEquals(1, countingRunListener.testAssumptionFailure);
         Assert.assertEquals(0, countingRunListener.testIgnored);
     }
 
     public static class TestTest {
         @Test
         public void pass() {}
 
         @Test
         public void fail() {
             throw new AssertionError("Thrown from @Test");
         }
 
         @Ignore
         @Test
         public void ignore() {}
 
         @Test
         public void assumptionFail() {
             throw new AssumptionViolatedException("Thrown from @Test");
         }
     }
 
     @Test
     public void parentRunnerTestMethods() throws InitializationError {
         CountingRunListener countingRunListener = runTestWithParentRunner(TestTest.class);
         Assert.assertEquals(3, countingRunListener.testStarted);
         Assert.assertEquals(3, countingRunListener.testFinished);
         Assert.assertEquals(1, countingRunListener.testFailure);
         Assert.assertEquals(1, countingRunListener.testAssumptionFailure);
         Assert.assertEquals(1, countingRunListener.testIgnored);
     }
 
     private CountingRunListener runTestWithParentRunner(Class<?> testClass) throws InitializationError {
         CountingRunListener listener = new CountingRunListener();
         RunNotifier runNotifier = new RunNotifier();
         runNotifier.addListener(listener);
         ParentRunner runner = new BlockJUnit4ClassRunner(testClass);
         runner.run(runNotifier);
         return listener;
     }
 
     private static class CountingRunListener extends RunListener {
         private int testStarted = 0;
         private int testFinished = 0;
         private int testFailure = 0;
         private int testAssumptionFailure = 0;
         private int testIgnored = 0;
 
         @Override
         public void testStarted(Description description) throws Exception {
             testStarted++;
         }
 
         @Override
         public void testFinished(Description description) throws Exception {
             testFinished++;
         }
 
         @Override
         public void testFailure(Failure failure) throws Exception {
             testFailure++;
         }
 
         @Override
         public void testAssumptionFailure(Failure failure) {
             testAssumptionFailure++;
         }
 
         @Override
         public void testIgnored(Description description) throws Exception {
             testIgnored++;
         }
     }
 }