- statically imported Collections where appropriate

- refactored the construction of the incompatiable annotations of CategoryValidator to be initialized immediately

Author: Ricky

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

@@ -1,9 +1,12 @@
 package org.junit.experimental.categories;
 
+import static java.util.Collections.unmodifiableList;
+import static java.util.Collections.unmodifiableSet;
+import static java.util.Arrays.asList;
+
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -23,44 +26,36 @@
  */
 public final class CategoryValidator extends AnnotationValidator {
 
-    private static Set<Class<? extends Annotation>> fIncompatibleAnnotations = buildIncompatibleAnnotationsSet();
+    private static final Set<Class<? extends Annotation>> INCOMPATIBLE_ANNOTATIONS = unmodifiableSet(new HashSet<Class<? extends Annotation>>(
+            asList(BeforeClass.class, AfterClass.class, Before.class, After.class)));
 
     /**
      * Adds to {@code errors} a throwable for each problem detected. Looks for
      * {@code BeforeClass}, {@code AfterClass}, {@code Before} and {@code After}
      * annotations.
      *
      * @param method the method that is being validated
-     * @return A list of errors detected
+     * @return A list of exceptions detected
      *
      * @since 4.12
      */
     @Override
-    public List<Throwable> validateAnnotatedMethod(Method method) {
-        List<Throwable> errors = new ArrayList<Throwable>();
+    public List<Exception> validateAnnotatedMethod(Method method) {
+        List<Exception> errors = new ArrayList<Exception>();
         Annotation[] declaredAnnotations = method.getDeclaredAnnotations();
         for (Annotation annotation : declaredAnnotations) {
-            for (Class clazz : fIncompatibleAnnotations) {
+            for (Class clazz : INCOMPATIBLE_ANNOTATIONS) {
                 if (annotation.annotationType().isAssignableFrom(clazz)) {
                     addErrorMessage(errors, clazz);
                 }
             }
         }
-        return Collections.unmodifiableList(errors);
-    }
-
-    private static Set<Class<? extends Annotation>> buildIncompatibleAnnotationsSet() {
-        Set<Class<? extends Annotation>> incompatibleAnnotations = new HashSet<Class<? extends Annotation>>();
-        incompatibleAnnotations.add(BeforeClass.class);
-        incompatibleAnnotations.add(AfterClass.class);
-        incompatibleAnnotations.add(Before.class);
-        incompatibleAnnotations.add(After.class);
-        return Collections.unmodifiableSet(incompatibleAnnotations);
+        return unmodifiableList(errors);
     }
 
-    private void addErrorMessage(List<Throwable> errors, Class clazz) {
+    private void addErrorMessage(List<Exception> errors, Class clazz) {
         String message = String.format("@%s can not be combined with @Category",
                 clazz.getSimpleName());
-        errors.add(new Throwable(message));
+        errors.add(new Exception(message));
     }
 }

src/main/java/org/junit/validator/AnnotationValidator.java

@@ -1,8 +1,9 @@
 package org.junit.validator;
 
+import static java.util.Collections.emptyList;
+
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.Collections;
 import java.util.List;
 
 /**
@@ -15,40 +16,43 @@
  * @since 4.12
  */
 public abstract class AnnotationValidator {
+
+    private static final List<Exception> NO_VALIDATION_ERRORS = emptyList();
+
     /**
      * Validates annotation on the given class.
      *
      * @param type that is being validated
-     * @return A list of throwables. Default behavior is to return an empty list.
+     * @return A list of exceptions. Default behavior is to return an empty list.
      *
      * @since 4.12
      */
-    public List<Throwable> validateAnnotatedClass(Class<?> type) {
-        return Collections.emptyList();
+    public List<Exception> validateAnnotatedClass(Class<?> type) {
+        return NO_VALIDATION_ERRORS;
     }
 
     /**
      * Validates annotation on the given field.
      *
      * @param field that is being validated
-     * @return A list of throwables. Default behavior is to return an empty list.
+     * @return A list of exceptions. Default behavior is to return an empty list.
      *
      * @since 4.12
      */
-    public List<Throwable> validateAnnotatedField(Field field) {
-        return Collections.emptyList();
+    public List<Exception> validateAnnotatedField(Field field) {
+        return NO_VALIDATION_ERRORS;
 
     }
 
     /**
      * Validates annotation on the given method.
      *
      * @param method that is being validated
-     * @return A list of throwables. Default behavior is to return an empty list.
+     * @return A list of exceptions. Default behavior is to return an empty list.
      *
      * @since 4.12
      */
-    public List<Throwable> validateAnnotatedMethod(Method method) {
-        return Collections.emptyList();
+    public List<Exception> validateAnnotatedMethod(Method method) {
+        return NO_VALIDATION_ERRORS;
     }
 }

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

@@ -1,6 +1,9 @@
 package org.junit.tests.experimental.categories;
 
 
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
 import java.lang.reflect.Method;
 import java.util.List;
 
@@ -12,9 +15,6 @@
 import org.junit.experimental.categories.Category;
 import org.junit.experimental.categories.CategoryValidator;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
-
 public class CategoryValidatorTest {
 
     public static class SampleCategory {
@@ -71,17 +71,17 @@ public void errorIsAddedWhenCategoryIsUsedWithAfter() throws NoSuchMethodExcepti
     }
 
     private void testAndAssertErrrorMessage(Method method, String expectedErrorMessage) throws NoSuchMethodException {
-        List<Throwable> errors = new CategoryValidator().validateAnnotatedMethod(method);
+        List<Exception> errors = new CategoryValidator().validateAnnotatedMethod(method);
 
         assertThat(errors.size(), is(1));
-        Throwable throwable = errors.get(0);
-        assertThat(throwable.getMessage(), is(expectedErrorMessage));
+        Exception exception = errors.get(0);
+        assertThat(exception.getMessage(), is(expectedErrorMessage));
     }
 
     @Test
     public void errorIsNotAddedWhenCategoryIsNotCombinedWithIllegalCombination() throws NoSuchMethodException {
         Method beforeClass = CategoryTest.class.getMethod("methodWithCategory");
-        List<Throwable> errors = new CategoryValidator().validateAnnotatedMethod(beforeClass);
+        List<Exception> errors = new CategoryValidator().validateAnnotatedMethod(beforeClass);
 
         assertThat(errors.size(), is(0));
     }

src/test/java/org/junit/tests/running/classes/ParentRunnerTest.java

@@ -25,9 +25,9 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
+import static java.util.Arrays.asList;
 import static org.hamcrest.core.IsCollectionContaining.hasItem;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
@@ -154,18 +154,18 @@ public static class ExampleAnnotationValidator extends AnnotationValidator {
         private static final String ANNOTATED_CLASS_CALLED = "annotated class called";
 
         @Override
-        public List<Throwable> validateAnnotatedClass(Class<?> type) {
-            return Arrays.asList(new Throwable(ANNOTATED_CLASS_CALLED));
+        public List<Exception> validateAnnotatedClass(Class<?> type) {
+            return asList(new Exception(ANNOTATED_CLASS_CALLED));
         }
 
         @Override
-        public List<Throwable> validateAnnotatedField(Field field) {
-            return Arrays.asList(new Throwable(ANNOTATED_FIELD_CALLED));
+        public List<Exception> validateAnnotatedField(Field field) {
+            return asList(new Exception(ANNOTATED_FIELD_CALLED));
         }
 
         @Override
-        public List<Throwable> validateAnnotatedMethod(Method method) {
-            return Arrays.asList(new Throwable(ANNOTATED_METHOD_CALLED));
+        public List<Exception> validateAnnotatedMethod(Method method) {
+            return asList(new Exception(ANNOTATED_METHOD_CALLED));
         }
     }