Add public CategoryFilter constructor that was removed in JUnit 4.12

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

@@ -2,8 +2,10 @@
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.Set;
 
 import org.junit.runner.Description;
@@ -117,10 +119,7 @@ public static class CategoryFilter extends Filter {
         private final boolean excludedAny;
 
         public static CategoryFilter include(boolean matchAny, Class<?>... categories) {
-            if (hasNull(categories)) {
-                throw new NullPointerException("has null category");
-            }
-            return categoryFilter(matchAny, createSet(categories), true, null);
+            return new CategoryFilter(matchAny, categories, true, null);
         }
 
         public static CategoryFilter include(Class<?> category) {
@@ -132,10 +131,7 @@ public static CategoryFilter include(Class<?>... categories) {
         }
 
         public static CategoryFilter exclude(boolean matchAny, Class<?>... categories) {
-            if (hasNull(categories)) {
-                throw new NullPointerException("has null category");
-            }
-            return categoryFilter(true, null, matchAny, createSet(categories));
+            return new CategoryFilter(true, null, matchAny, categories);
         }
 
         public static CategoryFilter exclude(Class<?> category) {
@@ -151,14 +147,30 @@ public static CategoryFilter categoryFilter(boolean matchAnyInclusions, Set<Clas
             return new CategoryFilter(matchAnyInclusions, inclusions, matchAnyExclusions, exclusions);
         }
 
+        @Deprecated
+        public CategoryFilter(Class<?> includedCategory, Class<?> excludedCategory) {
+            includedAny = true;
+            excludedAny = true;
+            included = nullableClassToSet(includedCategory);
+            excluded = nullableClassToSet(excludedCategory);
+        }
+
         protected CategoryFilter(boolean matchAnyIncludes, Set<Class<?>> includes,
-                               boolean matchAnyExcludes, Set<Class<?>> excludes) {
+                                 boolean matchAnyExcludes, Set<Class<?>> excludes) {
             includedAny = matchAnyIncludes;
             excludedAny = matchAnyExcludes;
             included = copyAndRefine(includes);
             excluded = copyAndRefine(excludes);
         }
 
+        private CategoryFilter(boolean matchAnyIncludes, Class<?>[] inclusions,
+                               boolean matchAnyExcludes, Class<?>[] exclusions) {
+            includedAny = matchAnyIncludes; 
+            excludedAny = matchAnyExcludes;
+            included = createSet(inclusions);
+            excluded = createSet(exclusions);
+        }
+
         /**
          * @see #toString()
          */
@@ -284,23 +296,13 @@ private static Class<?>[] directCategories(Description description) {
         }
 
         private static Set<Class<?>> copyAndRefine(Set<Class<?>> classes) {
-            Set<Class<?>> c= new HashSet<Class<?>>();
+            Set<Class<?>> c= new LinkedHashSet<Class<?>>();
             if (classes != null) {
                 c.addAll(classes);
             }
             c.remove(null);
             return c;
         }
-
-        private static boolean hasNull(Class<?>... classes) {
-            if (classes == null) return false;
-            for (Class<?> clazz : classes) {
-                if (clazz == null) {
-                    return true;
-                }
-            }
-            return false;
-        }
     }
 
     public Categories(Class<?> klass, RunnerBuilder builder) throws InitializationError {
@@ -346,11 +348,28 @@ private static boolean hasAssignableTo(Set<Class<?>> assigns, Class<?> to) {
         return false;
     }
 
-    private static Set<Class<?>> createSet(Class<?>... t) {
-        final Set<Class<?>> set= new HashSet<Class<?>>();
-        if (t != null) {
-            Collections.addAll(set, t);
+    private static Set<Class<?>> createSet(Class<?>[] classes) {
+        // Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.12
+        // for include(boolean, Class<?>...) and exclude(boolean, Class<?>...)
+        if (classes == null || classes.length == 0) {
+            return Collections.emptySet();
+        }
+        for (Class<?> category : classes) {
+            if (category == null) {
+                throw new NullPointerException("has null category");
+            }
         }
-        return set;
+
+        return classes.length == 1
+            ? Collections.<Class<?>>singleton(classes[0])
+            : new LinkedHashSet<Class<?>>(Arrays.asList(classes));
+    }
+
+    private static Set<Class<?>> nullableClassToSet(Class<?> nullableClass) {
+        // Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.11
+        // for CategoryFilter(Class<?> includedCategory, Class<?> excludedCategory)
+        return nullableClass == null
+                ? Collections.<Class<?>>emptySet()
+                : Collections.<Class<?>>singleton(nullableClass);
     }
 }

src/test/java/org/junit/experimental/categories/CategoryTest.java

@@ -179,14 +179,32 @@ public static class TestSuiteWithNoCategories {
     }
 
     @Test
-    public void testCountWithExplicitFilter() throws Throwable {
+    public void testCountWithExplicitIncludeFilter() throws Throwable {
         CategoryFilter include = CategoryFilter.include(SlowTests.class);
         Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class);
         Result result = new JUnitCore().run(baseRequest.filterWith(include));
         assertTrue(result.wasSuccessful());
         assertEquals(2, result.getRunCount());
     }
 
+    @Test
+    public void testCountWithExplicitExcludeFilter() throws Throwable {
+        CategoryFilter include = CategoryFilter.exclude(SlowTests.class);
+        Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class);
+        Result result = new JUnitCore().run(baseRequest.filterWith(include));
+        assertEquals(2, result.getFailureCount());
+        assertEquals(2, result.getRunCount());
+    }
+
+    @Test
+    public void testCountWithExplicitExcludeFilter_usingConstructor() throws Throwable {
+        CategoryFilter include = new CategoryFilter(null, SlowTests.class);
+        Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class);
+        Result result = new JUnitCore().run(baseRequest.filterWith(include));
+        assertEquals(2, result.getFailureCount());
+        assertEquals(2, result.getRunCount());
+    }
+
     @Test
     public void categoryFilterLeavesOnlyMatchingMethods()
             throws InitializationError, NoTestsRemainException {
@@ -196,6 +214,15 @@ public void categoryFilterLeavesOnlyMatchingMethods()
         assertEquals(1, runner.testCount());
     }
 
+    @Test
+    public void categoryFilterLeavesOnlyMatchingMethods_usingConstructor()
+            throws InitializationError, NoTestsRemainException {
+        CategoryFilter filter = new CategoryFilter(SlowTests.class, null);
+        BlockJUnit4ClassRunner runner = new BlockJUnit4ClassRunner(A.class);
+        filter.apply(runner);
+        assertEquals(1, runner.testCount());
+    }
+
     public static class OneFastOneSlow {
         @Category(FastTests.class)
         @Test