Add back public CategoryFilter constructor that was removed in JUnit 4.12.

Author: kcooney

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

@@ -2,6 +2,7 @@
 
 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.Set;
@@ -120,7 +121,7 @@ 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) {
@@ -135,7 +136,7 @@ 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 +152,27 @@ public static CategoryFilter categoryFilter(boolean matchAnyInclusions, Set<Clas
             return new CategoryFilter(matchAnyInclusions, inclusions, matchAnyExclusions, exclusions);
         }
 
+        @Deprecated
+        public CategoryFilter(Class<?> includedCategory, Class<?> excludedCategory) {
+            this(true, createSet(includedCategory), true, createSet(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()
          */
@@ -347,10 +361,11 @@ private static boolean hasAssignableTo(Set<Class<?>> assigns, Class<?> to) {
     }
 
     private static Set<Class<?>> createSet(Class<?>... t) {
-        final Set<Class<?>> set= new HashSet<Class<?>>();
-        if (t != null) {
-            Collections.addAll(set, t);
+        if (t == null || t.length == 0) {
+            return Collections.emptySet();
+        } else if (t.length == 1) {
+            return Collections.<Class<?>>singleton(t[0]);
         }
-        return set;
+        return new HashSet<Class<?>>(Arrays.asList(t));
     }
 }

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