package org.junit.runner;
   
   import static org.hamcrest.CoreMatchers.instanceOf;
   import static org.hamcrest.CoreMatchers.is;
   import static org.hamcrest.CoreMatchers.startsWith;
   import static org.hamcrest.MatcherAssert.assertThat;
   import static org.junit.Assume.assumeThat;
   import org.junit.Rule;
   import org.junit.Test;
  import org.junit.experimental.categories.ExcludeCategories;
  import org.junit.rules.ExpectedException;
  import org.junit.rules.TestName;
  import org.junit.runner.manipulation.Filter;
  import org.junit.runners.Suite;
  import org.junit.runners.Suite.SuiteClasses;
  
  public class FilterFactoriesTest {
      @Rule
      public ExpectedException expectedException = ExpectedException.none();
  
      @Rule
      public TestName testName = new TestName();
  
      private Request createSuiteRequest() {
          return Request.aClass(DummySuite.class);
      }
  
      @Test
      public void shouldCreateFilterWithArguments() throws Exception {
          Filter filter = FilterFactories.createFilterFromFilterSpec(
                  createSuiteRequest(),
                  ExcludeCategories.class.getName() + "=" + DummyCategory.class.getName());
  
          assertThat(filter.describe(), startsWith("excludes "));
      }
  
      @Test
      public void shouldCreateFilterWithNoArguments() throws Exception {
          Filter filter = FilterFactories.createFilterFromFilterSpec(
                  createSuiteRequest(), FilterFactoryStub.class.getName());
  
          assertThat(filter, instanceOf(DummyFilter.class));
      }
  
      @Test
      public void shouldPassOnDescriptionToFilterFactory() throws Exception {
          Request request = createSuiteRequest();
          Description description = request.getRunner().getDescription();
          Filter filter = FilterFactories.createFilterFromFilterSpec(
                  request, FilterFactoryStub.class.getName());
  
          // This assumption tested in shouldCreateFilterWithNoArguments()
          assumeThat(filter, instanceOf(DummyFilter.class));
  
          DummyFilter dummyFilter = (DummyFilter) filter;
          assertThat(dummyFilter.getTopLevelDescription(), is(description));
      }
  
      @Test
      public void shouldCreateFilter() throws Exception {
          Filter filter = FilterFactories.createFilter(
                  FilterFactoryStub.class,
                  new FilterFactoryParams(
                          Description.createSuiteDescription(testName.getMethodName()),
                          ""));
  
          assertThat(filter, instanceOf(DummyFilter.class));
      }
  
      @Test
      public void shouldThrowExceptionIfNotFilterFactory() throws Exception {
          expectedException.expect(FilterFactory.FilterNotCreatedException.class);
  
          FilterFactories.createFilterFactory(NonFilterFactory.class.getName());
      }
  
      @Test
      public void shouldThrowExceptionIfNotInstantiable() throws Exception {
          expectedException.expect(FilterFactory.FilterNotCreatedException.class);
  
          FilterFactories.createFilterFactory(NonInstantiableFilterFactory.class);
      }
  
      public static class NonFilterFactory {
      }
  
      public static class NonInstantiableFilterFactory implements FilterFactory {
          private NonInstantiableFilterFactory() {
          }
  
          public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
              throw new FilterNotCreatedException(new Exception("not implemented"));
          }
      }
  
      public static class FilterFactoryStub implements FilterFactory {
          public Filter createFilter(FilterFactoryParams params) {
              return new DummyFilter(params.getTopLevelDescription());
          }
     }
 
     private static class DummyFilter extends Filter {
         private final Description fTopLevelDescription;
 
         public DummyFilter(Description topLevelDescription) {
             fTopLevelDescription = topLevelDescription;
         }
 
         public Description getTopLevelDescription() {
             return fTopLevelDescription;
         }
 
         @Override
         public boolean shouldRun(Description description) {
             return false;
         }
 
         @Override
         public String describe() {
             return null;
         }
     }
 
     public static class DummyCategory {
     }
 
     @RunWith(Suite.class)
     @SuiteClasses(DummyTest.class)
     public static class DummySuite {
     }
 
     public static class DummyTest {
         @Test
         public void passes() {
         }
     }
 }