Avoid null pointer exception on non-present annotations.

Author: raphw

byte-buddy-dep/src/main/java/net/bytebuddy/description/annotation/AnnotationList.java

@@ -233,12 +233,24 @@ public ForLoadedAnnotations(Annotation... annotation) {
         }
 
         /**
-         * Creates a new list of loaded annotations.
+         * Creates a new list of loaded annotations. Any {@code null} entries are filtered out as the JVM's
+         * reflection API can return {@code null} for annotations whose annotation type is not available on
+         * the class path.
          *
          * @param annotations The represented annotations.
          */
         public ForLoadedAnnotations(List<? extends Annotation> annotations) {
-            this.annotations = annotations;
+            List<Annotation> resolved = null;
+            for (int index = 0; index < annotations.size(); index++) {
+                if (annotations.get(index) == null) {
+                    if (resolved == null) {
+                        resolved = new ArrayList<Annotation>(annotations.subList(0, index));
+                    }
+                } else if (resolved != null) {
+                    resolved.add(annotations.get(index));
+                }
+            }
+            this.annotations = resolved == null ? annotations : resolved;
         }
 
         /**

byte-buddy-dep/src/main/java/net/bytebuddy/utility/AnnotationComparator.java

@@ -15,6 +15,8 @@
  */
 package net.bytebuddy.utility;
 
+import net.bytebuddy.utility.nullability.MaybeNull;
+
 import java.lang.annotation.Annotation;
 import java.util.Comparator;
 
@@ -31,9 +33,13 @@ public enum AnnotationComparator implements Comparator<Annotation> {
     /**
      * {@inheritDoc}
      */
-    public int compare(Annotation left, Annotation right) {
+    public int compare(@MaybeNull Annotation left, @MaybeNull Annotation right) {
         if (left == right) {
             return 0;
+        } else if (left == null) {
+            return 1;
+        } else if (right == null) {
+            return -1;
         }
         return left.annotationType().getName().compareTo(right.annotationType().getName());
     }

byte-buddy-dep/src/main/java/net/bytebuddy/utility/ConstructorComparator.java

@@ -15,6 +15,8 @@
  */
 package net.bytebuddy.utility;
 
+import net.bytebuddy.utility.nullability.MaybeNull;
+
 import java.lang.reflect.Constructor;
 import java.util.Comparator;
 
@@ -31,9 +33,13 @@ public enum ConstructorComparator implements Comparator<Constructor<?>> {
     /**
      * {@inheritDoc}
      */
-    public int compare(Constructor<?> left, Constructor<?> right) {
+    public int compare(@MaybeNull Constructor<?> left, @MaybeNull Constructor<?> right) {
         if (left == right) {
             return 0;
+        } else if (left == null) {
+            return 1;
+        } else if (right == null) {
+            return -1;
         }
         int comparison = left.getName().compareTo(right.getName());
         if (comparison == 0) {

byte-buddy-dep/src/main/java/net/bytebuddy/utility/FieldComparator.java

@@ -15,6 +15,8 @@
  */
 package net.bytebuddy.utility;
 
+import net.bytebuddy.utility.nullability.MaybeNull;
+
 import java.lang.reflect.Field;
 import java.util.Comparator;
 
@@ -31,9 +33,13 @@ public enum FieldComparator implements Comparator<Field> {
     /**
      * {@inheritDoc}
      */
-    public int compare(Field left, Field right) {
+    public int compare(@MaybeNull Field left, @MaybeNull Field right) {
         if (left == right) {
             return 0;
+        } else if (left == null) {
+            return 1;
+        } else if (right == null) {
+            return -1;
         }
         int comparison = left.getName().compareTo(right.getName());
         if (comparison == 0) {

byte-buddy-dep/src/main/java/net/bytebuddy/utility/MethodComparator.java

@@ -15,6 +15,8 @@
  */
 package net.bytebuddy.utility;
 
+import net.bytebuddy.utility.nullability.MaybeNull;
+
 import java.lang.reflect.Method;
 import java.util.Comparator;
 
@@ -31,9 +33,13 @@ public enum MethodComparator implements Comparator<Method> {
     /**
      * {@inheritDoc}
      */
-    public int compare(Method left, Method right) {
+    public int compare(@MaybeNull Method left, @MaybeNull Method right) {
         if (left == right) {
             return 0;
+        } else if (left == null) {
+            return 1;
+        } else if (right == null) {
+            return -1;
         }
         int comparison = left.getName().compareTo(right.getName());
         if (comparison == 0) {

byte-buddy-dep/src/main/java/net/bytebuddy/utility/TypeComparator.java

@@ -15,6 +15,8 @@
  */
 package net.bytebuddy.utility;
 
+import net.bytebuddy.utility.nullability.MaybeNull;
+
 import java.util.Comparator;
 
 /**
@@ -30,9 +32,13 @@ public enum TypeComparator implements Comparator<Class<?>> {
     /**
      * {@inheritDoc}
      */
-    public int compare(Class<?> left, Class<?> right) {
+    public int compare(@MaybeNull Class<?> left, @MaybeNull Class<?> right) {
         if (left == right) {
             return 0;
+        } else if (left == null) {
+            return 1;
+        } else if (right == null) {
+            return -1;
         }
         return left.getName().compareTo(right.getName());
     }

byte-buddy-dep/src/test/java/net/bytebuddy/description/annotation/AnnotationListForLoadedAnnotationsTest.java

@@ -1,8 +1,15 @@
 package net.bytebuddy.description.annotation;
 
+import org.junit.Test;
+
 import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
 public class AnnotationListForLoadedAnnotationsTest extends AbstractAnnotationListTest<Annotation> {
 
     protected Annotation getFirst() throws Exception {
@@ -20,4 +27,38 @@ protected AnnotationList asList(List<Annotation> elements) {
     protected AnnotationDescription asElement(Annotation element) {
         return new AnnotationDescription.ForLoadedAnnotation<Annotation>(element);
     }
+
+    @Test
+    public void testFiltersNullEntriesFromArray() throws Exception {
+        AnnotationList list = new AnnotationList.ForLoadedAnnotations(getFirst(), null, getSecond());
+        assertThat(list.size(), is(2));
+        assertThat(list.isAnnotationPresent(Foo.class), is(true));
+        assertThat(list.isAnnotationPresent(Bar.class), is(true));
+    }
+
+    @Test
+    public void testFiltersNullEntriesFromList() throws Exception {
+        AnnotationList list = new AnnotationList.ForLoadedAnnotations(Arrays.asList(getFirst(), null, getSecond()));
+        assertThat(list.size(), is(2));
+        assertThat(list.isAnnotationPresent(Foo.class), is(true));
+        assertThat(list.isAnnotationPresent(Bar.class), is(true));
+    }
+
+    @Test
+    public void testAllNullEntriesYieldEmptyList() throws Exception {
+        AnnotationList list = new AnnotationList.ForLoadedAnnotations(Arrays.<Annotation>asList(null, null));
+        assertThat(list.size(), is(0));
+    }
+
+    @Test
+    public void testNullArrayEntriesAreFiltered() throws Exception {
+        AnnotationList list = new AnnotationList.ForLoadedAnnotations(new Annotation[]{null});
+        assertThat(list.size(), is(0));
+    }
+
+    @Test
+    public void testEmptyListIsPreserved() throws Exception {
+        AnnotationList list = new AnnotationList.ForLoadedAnnotations(Collections.<Annotation>emptyList());
+        assertThat(list.size(), is(0));
+    }
 }

byte-buddy-dep/src/test/java/net/bytebuddy/utility/AnnotationComparatorTest.java

@@ -29,4 +29,11 @@ public void testTypeComparison() {
         assertThat(AnnotationComparator.INSTANCE.compare(left, right) < 0, is(true));
         assertThat(AnnotationComparator.INSTANCE.compare(right, left) > 0, is(true));
     }
+
+    @Test
+    public void testNullSafe() {
+        assertThat(AnnotationComparator.INSTANCE.compare(null, null) == 0, is(true));
+        assertThat(AnnotationComparator.INSTANCE.compare(null, right) > 0, is(true));
+        assertThat(AnnotationComparator.INSTANCE.compare(left, null) < 0, is(true));
+    }
 }

byte-buddy-dep/src/test/java/net/bytebuddy/utility/ConstructorComparatorTest.java

@@ -37,6 +37,13 @@ public void testComparisonSingleSingle() throws Exception {
                 Sample.class.getDeclaredConstructor(String.class)), is(-10));
     }
 
+    @Test
+    public void testNullSafe() throws Exception {
+        assertThat(ConstructorComparator.INSTANCE.compare(null, null) == 0, is(true));
+        assertThat(ConstructorComparator.INSTANCE.compare(null, Sample.class.getDeclaredConstructor()) > 0, is(true));
+        assertThat(ConstructorComparator.INSTANCE.compare(Sample.class.getDeclaredConstructor(), null) < 0, is(true));
+    }
+
     @SuppressWarnings("unused")
     private static class Sample {
 

byte-buddy-dep/src/test/java/net/bytebuddy/utility/FieldComparatorTest.java

@@ -24,6 +24,13 @@ public void testComparisonDifferent() throws Exception {
                 Sample.class.getDeclaredField("first")), is(13));
     }
 
+    @Test
+    public void testNullSafe() throws Exception {
+        assertThat(FieldComparator.INSTANCE.compare(null, null) == 0, is(true));
+        assertThat(FieldComparator.INSTANCE.compare(null, Sample.class.getDeclaredField("first")) > 0, is(true));
+        assertThat(FieldComparator.INSTANCE.compare(Sample.class.getDeclaredField("first"), null) < 0, is(true));
+    }
+
     @SuppressWarnings("unused")
     private static class Sample {