--filter option implemented.

src/main/java/org/junit/experimental/categories/Categories.java

@@ -2,9 +2,10 @@
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
-import java.util.Set;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Set;
+
 import org.junit.runner.Description;
 import org.junit.runner.manipulation.Filter;
 import org.junit.runner.manipulation.NoTestsRemainException;
@@ -154,7 +155,7 @@ public static CategoryFilter categoryFilter(boolean matchAnyInclusions, Set<Clas
             return new CategoryFilter(matchAnyInclusions, inclusions, matchAnyExclusions, exclusions);
         }
 
-        private CategoryFilter(boolean matchAnyIncludes, Set<Class<?>> includes,
+        protected CategoryFilter(boolean matchAnyIncludes, Set<Class<?>> includes,
                                boolean matchAnyExcludes, Set<Class<?>> excludes) {
             fIncludedAny= matchAnyIncludes;
             fExcludedAny= matchAnyExcludes;

src/main/java/org/junit/experimental/categories/CategoryFilterFactory.java

@@ -0,0 +1,50 @@
+package org.junit.experimental.categories;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.internal.Classes;
+import org.junit.runner.FilterFactory;
+import org.junit.runner.FilterFactoryParams;
+import org.junit.runner.manipulation.Filter;
+
+/**
+ * Implementation of FilterFactory for Category filtering.
+ */
+public abstract class CategoryFilterFactory implements FilterFactory {
+    /**
+     * Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given a
+     * ${FilterFactoryParams} argument.
+     *
+     * @param params Parameters needed to create the {@link Filter}
+     * @throws FilterNotCreatedException
+     */
+    @Override
+    public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
+        try {
+            return createFilter(parseCategories(params.getArgs()));
+        } catch (ClassNotFoundException e) {
+            throw new FilterNotCreatedException(e);
+        }
+    }
+
+    /**
+     * Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given an array of classes used as
+     * {@link Category} values.
+     *
+     * @param categories Category classes.
+     */
+    protected abstract Filter createFilter(Class<?>... categories);
+
+    private Class<?>[] parseCategories(String categories) throws ClassNotFoundException {
+        List<Class<?>> categoryClasses = new ArrayList<Class<?>>();
+
+        for (String category : categories.split(",")) {
+            Class<?> categoryClass = Classes.getClass(category);
+
+            categoryClasses.add(categoryClass);
+        }
+
+        return categoryClasses.toArray(new Class[]{});
+    }
+}

src/main/java/org/junit/experimental/categories/ExcludeCategories.java

@@ -0,0 +1,54 @@
+package org.junit.experimental.categories;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.runner.manipulation.Filter;
+
+import static org.junit.experimental.categories.Categories.CategoryFilter;
+
+/**
+ * {@link org.junit.runner.FilterFactory} to exclude categories.
+ *
+ * The {@link Filter} that is created will filter out tests that are categorized with any of the
+ * given categories.
+ *
+ * Usage from command line:
+ * <code>
+ *     --filter=org.junit.experimental.categories.ExcludeCategories=pkg.of.Cat1,pkg.of.Cat2
+ * </code>
+ *
+ * Usage from API:
+ * <code>
+ *     new ExcludeCategories().createFilter(Cat1.class, Cat2.class);
+ * </code>
+ */
+public final class ExcludeCategories extends CategoryFilterFactory {
+    /**
+     * Creates an {@link ExcludesAny} {@link CategoryFilter} given an array of classes used as
+     * {@link Category} values.
+     *
+     * @param categories Category classes.
+     * @return
+     */
+    @Override
+    protected Filter createFilter(Class<?>... categories) {
+        return new ExcludesAny(categories);
+    }
+
+    private static class ExcludesAny extends CategoryFilter {
+        public ExcludesAny(Class<?>... categories) {
+            this(new HashSet<Class<?>>(Arrays.asList(categories)));
+        }
+
+        public ExcludesAny(Set<Class<?>> categories) {
+            super(true, null, true, categories);
+        }
+
+        @Override
+        public String describe() {
+            return "excludes " + super.describe();
+        }
+    }
+}

src/main/java/org/junit/experimental/categories/IncludeCategories.java

@@ -0,0 +1,54 @@
+package org.junit.experimental.categories;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.runner.manipulation.Filter;
+
+import static org.junit.experimental.categories.Categories.CategoryFilter;
+
+/**
+ * {@link org.junit.runner.FilterFactory} to include categories.
+ *
+ * The {@link Filter} that is created will filter out tests that are categorized with any of the
+ * given categories.
+ *
+ * Usage from command line:
+ * <code>
+ *     --filter=org.junit.experimental.categories.IncludeCategories=pkg.of.Cat1,pkg.of.Cat2
+ * </code>
+ *
+ * Usage from API:
+ * <code>
+ *     new IncludeCategories().createFilter(Cat1.class, Cat2.class);
+ * </code>
+ */
+public final class IncludeCategories extends CategoryFilterFactory {
+    /**
+     * Creates an {@link IncludesAny} {@link CategoryFilter} given an array of classes used as
+     * {@link Category} values.
+     *
+     * @param categories Category classes.
+     * @return
+     */
+    @Override
+    protected Filter createFilter(Class<?>... categories) {
+        return new IncludesAny(categories);
+    }
+
+    private static class IncludesAny extends CategoryFilter {
+        public IncludesAny(Class<?>... categories) {
+            this(new HashSet<Class<?>>(Arrays.asList(categories)));
+        }
+
+        public IncludesAny(Set<Class<?>> categories) {
+            super(true, categories, true, null);
+        }
+
+        @Override
+        public String describe() {
+            return "includes " + super.describe();
+        }
+    }
+}

src/main/java/org/junit/internal/Classes.java

@@ -0,0 +1,18 @@
+package org.junit.internal;
+
+import static java.lang.Thread.currentThread;
+
+/**
+ * Miscellaneous functions dealing with classes.
+ */
+public class Classes {
+    /**
+     * Returns Class.forName for {@code className} using the current thread's class loader.
+     *
+     * @param className Name of the class.
+     * @throws ClassNotFoundException
+     */
+    public static Class<?> getClass(String className) throws ClassNotFoundException {
+        return Class.forName(className, true, currentThread().getContextClassLoader());
+    }
+}

src/main/java/org/junit/internal/runners/ErrorReportingRunner.java

@@ -53,7 +53,7 @@ private List<Throwable> getCauses(Throwable cause) {
 
     private Description describeCause(Throwable child) {
         return Description.createTestDescription(fTestClass,
-                "initializationError");
+                "initializationError: " + child);
     }
 
     private void runCause(Throwable child, RunNotifier notifier) {
@@ -62,4 +62,4 @@ private void runCause(Throwable child, RunNotifier notifier) {
         notifier.fireTestFailure(new Failure(description, child));
         notifier.fireTestFinished(description);
     }
-}
+}

src/main/java/org/junit/runner/FilterFactories.java

@@ -0,0 +1,94 @@
+package org.junit.runner;
+
+import org.junit.internal.Classes;
+import org.junit.runner.manipulation.Filter;
+
+import static org.junit.runner.FilterFactory.FilterNotCreatedException;
+
+/**
+ * Utility class whose methods create a {@link FilterFactory}.
+ */
+public class FilterFactories {
+    /**
+     * Creates a {@link Filter}.
+     *
+     * A filter specification is of the form "package.of.FilterFactory=args-to-filter-factory" or
+     * "package.of.FilterFactory".
+     *
+     * @param filterSpec The filter specification
+     * @throws FilterFactoryNotCreatedException
+     * @throws FilterNotCreatedException
+     */
+    public static Filter createFilterFromFilterSpec(Description description, String filterSpec)
+            throws FilterFactoryNotCreatedException {
+
+        if (filterSpec.contains("=")) {
+            String[] tuple = filterSpec.split("=", 2);
+
+            return createFilter(tuple[0], new FilterFactoryParams(description, tuple[1]));
+        } else {
+            return createFilter(filterSpec, new FilterFactoryParams(description));
+        }
+    }
+
+    /**
+     * Creates a {@link Filter}.
+     *
+     * @param filterFactoryFqcn The fully qualified class name of the {@link FilterFactory}
+     * @param params The arguments to the {@link FilterFactory}
+     * @throws FilterNotCreatedException
+     * @throws FilterFactoryNotCreatedException
+     */
+    public static Filter createFilter(String filterFactoryFqcn, FilterFactoryParams params)
+            throws FilterFactoryNotCreatedException {
+        FilterFactory filterFactory = createFilterFactory(filterFactoryFqcn);
+
+        return filterFactory.createFilter(params);
+    }
+
+    /**
+     * Creates a {@link Filter}.
+     *
+     * @param filterFactoryClass The class of the {@link FilterFactory}
+     * @param params             The arguments to the {@link FilterFactory}
+     * @throws FilterNotCreatedException
+     * @throws FilterFactoryNotCreatedException
+     *
+     */
+    public static Filter createFilter(Class<? extends FilterFactory> filterFactoryClass, FilterFactoryParams params)
+            throws FilterFactoryNotCreatedException {
+        FilterFactory filterFactory = createFilterFactory(filterFactoryClass);
+
+        return filterFactory.createFilter(params);
+    }
+
+    static FilterFactory createFilterFactory(String filterFactoryFqcn) throws FilterFactoryNotCreatedException {
+        Class<? extends FilterFactory> filterFactoryClass;
+
+        try {
+            filterFactoryClass = Classes.getClass(filterFactoryFqcn).asSubclass(FilterFactory.class);
+        } catch (Exception e) {
+            throw new FilterFactoryNotCreatedException(e);
+        }
+
+        return createFilterFactory(filterFactoryClass);
+    }
+
+    static FilterFactory createFilterFactory(Class<? extends FilterFactory> filterFactoryClass)
+            throws FilterFactoryNotCreatedException {
+        try {
+            return filterFactoryClass.getConstructor().newInstance();
+        } catch (Exception e) {
+            throw new FilterFactoryNotCreatedException(e);
+        }
+    }
+
+    /**
+     * Exception thrown if the {@link FilterFactory} cannot be created.
+     */
+    public static class FilterFactoryNotCreatedException extends ClassNotFoundException {
+        public FilterFactoryNotCreatedException(Exception exception) {
+            super(exception.getMessage(), exception);
+        }
+    }
+}

src/main/java/org/junit/runner/FilterFactory.java

@@ -0,0 +1,25 @@
+package org.junit.runner;
+
+import org.junit.runner.manipulation.Filter;
+
+/**
+ * Extend this class to create a factory that creates {@link Filter}.
+ */
+public interface FilterFactory {
+    /**
+     * Creates a {@link Filter} given a ${FilterFactoryParams} argument.
+     *
+     * @param params Parameters needed to create the {@link Filter}
+     * @throws FilterNotCreatedException
+     */
+    Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException;
+
+    /**
+     * Exception thrown if the {@link Filter} cannot be created.
+     */
+    static class FilterNotCreatedException extends FilterFactories.FilterFactoryNotCreatedException {
+        public FilterNotCreatedException(Exception exception) {
+            super(exception);
+        }
+    }
+}

src/main/java/org/junit/runner/FilterFactoryParams.java

@@ -0,0 +1,43 @@
+package org.junit.runner;
+
+/**
+ * Parameters to a {@link FilterFactory}.
+ */
+public final class FilterFactoryParams {
+    private final Description description;
+    private final String args;
+
+    /**
+     * Constructs a {@link FilterFactoryParams}.
+     *
+     * @param description {@link Description}
+     */
+    public FilterFactoryParams(Description description) {
+        this(description, null);
+    }
+
+    /**
+     * Constructs a {@link FilterFactoryParams}.
+     *
+     * @param description {@link Description}
+     * @param args Arguments
+     */
+    public FilterFactoryParams(Description description, String args) {
+        this.description = description;
+        this.args = args;
+    }
+
+    /**
+     * Returns the {@link Description}.
+     */
+    public Description getDescription() {
+        return description;
+    }
+
+    /**
+     * Returns the arguments.
+     */
+    public String getArgs() {
+        return args;
+    }
+}