Enables class-array as parameter to @IncludeCategory and @ExludeCategory

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

@@ -64,34 +64,54 @@ public class Categories extends Suite {
     // someday enable a better new implementation.
     // https://github.com/KentBeck/junit/issues/issue/172
 
+    /**
+     * {@link IncludeCategory} determines which Tests are ran by {@link Categories}.
+     * <p/>
+     *  If specified all Tests annotated with classes specified in the value of this annotation will be ran by
+     * {@link Categories} as long they are not specified using {@link ExcludeCategory}
+     */
     @Retention(RetentionPolicy.RUNTIME)
     public @interface IncludeCategory {
-        public Class<?> value();
+        public Class<?>[] value();
     }
 
+    /**
+     * {@link ExcludeCategory} determines which Tests are skipped by {@link Categories}.
+     * <p/>
+     * If specified all Tests annotated with classes specified in the value of this annotation will be skipped by
+     * {@link Categories} regardless of being mentioned in {@link IncludeCategory}
+     */
     @Retention(RetentionPolicy.RUNTIME)
     public @interface ExcludeCategory {
-        public Class<?> value();
+        public Class<?>[] value();
     }
 
     public static class CategoryFilter extends Filter {
+
         public static CategoryFilter include(Class<?> categoryType) {
+            return new CategoryFilter(new Class<?>[]{categoryType}, null);
+        }
+
+        public static CategoryFilter include(Class<?>[] categoryType) {
             return new CategoryFilter(categoryType, null);
         }
 
-        private final Class<?> fIncluded;
+        private final Class<?>[] includedCategories;
 
-        private final Class<?> fExcluded;
+        private final Class<?>[] excludedCategories;
 
-        public CategoryFilter(Class<?> includedCategory,
-                Class<?> excludedCategory) {
-            fIncluded = includedCategory;
-            fExcluded = excludedCategory;
+        public CategoryFilter(Class<?>[] includedCategories,
+                Class<?>[] excludedCategories) {
+            this.includedCategories = includedCategories;
+            this.excludedCategories = excludedCategories;
         }
 
         @Override
         public String describe() {
-            return "category " + fIncluded;
+            Integer numIncludedCategories = includedCategories == null ? 0 : includedCategories.length;
+            Integer numExcludedCategories = excludedCategories == null ? 0 : excludedCategories.length;
+            return "category. contains: " + numIncludedCategories + " included categories and "
+                    + numExcludedCategories + " excluded categories.";
         }
 
         @Override
@@ -107,18 +127,37 @@ public boolean shouldRun(Description description) {
             return false;
         }
 
+        /**
+         * Checks if the given array of classes (eg includedCategories) contains a given class
+         * This is used to determine if a specified class in a {@link Category} annotation is represented in the
+         * class-array specified in a {@link IncludeCategory} or {@link ExcludeCategory} annotation of a suite ran with
+         * {@link Categories}
+         *
+         * @param categories array of categories (specified value of {@link IncludeCategory} or {@link ExcludeCategory})
+         * @param category defined category (one of the classes specified in {@link Category})
+         * @return true if the given category class is assignable from any of the given classes in categories
+         */
+        private boolean containsCategory(Class<?>[] categories, Class<?> category){
+            for(Class<?> cat : categories){
+                if(cat.isAssignableFrom(category)){
+                    return true;
+                }
+            }
+            return false;
+        }
+
         private boolean hasCorrectCategoryAnnotation(Description description) {
             List<Class<?>> categories = categories(description);
             if (categories.isEmpty()) {
-                return fIncluded == null;
+                return includedCategories == null;
             }
-            for (Class<?> each : categories) {
-                if (fExcluded != null && fExcluded.isAssignableFrom(each)) {
+            for (Class<?> category : categories) {
+                if (excludedCategories != null && containsCategory(excludedCategories, category)) {
                     return false;
                 }
             }
-            for (Class<?> each : categories) {
-                if (fIncluded == null || fIncluded.isAssignableFrom(each)) {
+            for (Class<?> category : categories) {
+                if (includedCategories == null || containsCategory(includedCategories, category)) {
                     return true;
                 }
             }
@@ -156,20 +195,20 @@ public Categories(Class<?> klass, RunnerBuilder builder)
             throws InitializationError {
         super(klass, builder);
         try {
-            filter(new CategoryFilter(getIncludedCategory(klass),
-                    getExcludedCategory(klass)));
+            filter(new CategoryFilter(getIncludedCategories(klass),
+                    getExcludedCategories(klass)));
         } catch (NoTestsRemainException e) {
             throw new InitializationError(e);
         }
         assertNoCategorizedDescendentsOfUncategorizeableParents(getDescription());
     }
 
-    private Class<?> getIncludedCategory(Class<?> klass) {
+    private Class<?>[] getIncludedCategories(Class<?> klass) {
         IncludeCategory annotation = klass.getAnnotation(IncludeCategory.class);
         return annotation == null ? null : annotation.value();
     }
 
-    private Class<?> getExcludedCategory(Class<?> klass) {
+    private Class<?>[] getExcludedCategories(Class<?> klass) {
         ExcludeCategory annotation = klass.getAnnotation(ExcludeCategory.class);
         return annotation == null ? null : annotation.value();
     }

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

@@ -211,7 +211,7 @@ public void ifNoTestsToRunUseErrorRunner() {
     @Test
     public void describeACategoryFilter() {
         CategoryFilter filter = CategoryFilter.include(SlowTests.class);
-        assertEquals("category " + SlowTests.class, filter.describe());
+        assertEquals("category. contains: 1 included categories and 0 excluded categories.", filter.describe());
     }
 
     public static class OneThatIsBothFastAndSlow {

src/test/java/org/junit/tests/experimental/categories/MultipleClassesInIncludeCategoryAndExludeCategoryTest.java

@@ -0,0 +1,81 @@
+package org.junit.tests.experimental.categories;
+
+import org.junit.Test;
+import org.junit.experimental.categories.Categories;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+import static junit.framework.Assert.assertEquals;
+
+/**
+ * Author: Henning Gross
+ * Date: 04.12.12
+ */
+public class MultipleClassesInIncludeCategoryAndExludeCategoryTest {
+
+    // category markers
+    public interface IntegrationTests {
+    }
+
+    public interface SlowTests {
+    }
+
+    public static class A {
+        @Category(IntegrationTests.class)
+        @Test
+        public void a() {
+        }
+
+        @Category(SlowTests.class)
+        @Test
+        public void b() {
+        }
+
+        @Test
+        public void c() {
+        }
+    }
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory({SlowTests.class, IntegrationTests.class})
+    @Suite.SuiteClasses({A.class})
+    public static class IncludeCategorySuite {
+    }
+
+    @Test
+    public void testMultipleClassesInIncludeCategory() {
+        // a and b will be ran
+        Result result = JUnitCore.runClasses(IncludeCategorySuite.class);
+        assertEquals(2, result.getRunCount());
+    }
+
+    @RunWith(Categories.class)
+    @Categories.ExcludeCategory({SlowTests.class, IntegrationTests.class})
+    @Suite.SuiteClasses({A.class})
+    public static class ExcludeCategorySuite {
+    }
+
+    @Test
+    public void testMultipleClassesInExcludeCategory() {
+        // only c will be ran (not annotated, due to no @IncludeCategory specified)
+        Result result = JUnitCore.runClasses(ExcludeCategorySuite.class);
+        assertEquals(1, result.getRunCount());
+    }
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory(SlowTests.class)
+    @Categories.ExcludeCategory({SlowTests.class})
+    @Suite.SuiteClasses({A.class})
+    public static class OverrideIncludeCategorySuite {
+    }
+
+    @Test
+    public void testOverrideCategory() {
+        // only a will be ran (IntegrationTest)
+        Result result = JUnitCore.runClasses(ExcludeCategorySuite.class);
+        assertEquals(1, result.getRunCount());
+    }
+}