Add assertContainsOnlyNulls iterable/array assertion

Author: BillyYccc

src/main/java/org/assertj/core/api/AbstractIterableAssert.java

@@ -207,6 +207,15 @@ public SELF containsOnlyOnce(@SuppressWarnings("unchecked") ELEMENT... values) {
     return myself;
   }
 
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public SELF containsOnlyNulls() {
+    iterables.assertContainsOnlyNulls(info, actual);
+    return myself;
+  }
+
   /**
    * {@inheritDoc}
    */
@@ -368,7 +377,7 @@ public SELF endsWith(ELEMENT first, @SuppressWarnings("unchecked") ELEMENT... re
    * {@inheritDoc}
    */
   @Override
-  public SELF endsWith(@SuppressWarnings("unchecked") ELEMENT[] sequence) {
+  public SELF endsWith(ELEMENT[] sequence) {
     iterables.assertEndsWith(info, actual, sequence);
     return myself;
   }

src/main/java/org/assertj/core/api/AbstractObjectArrayAssert.java

@@ -270,6 +270,31 @@ public SELF containsOnlyElementsOf(Iterable<? extends ELEMENT> iterable) {
     return containsOnly(toArray(iterable));
   }
 
+  /**
+   * Verifies that the actual array contains only null elements.
+   * <p>
+   * Example :
+   * <pre><code class='java'> Person[] persons1 = {null, null, null};
+   * Person[] persons2 = {null, null, person};
+   *
+   * // assertion will pass
+   * assertThat(persons1).containsOnlyNulls();
+   *
+   * // assertions will fail
+   * assertThat(persons2).containsOnlyNulls();
+   * assertThat(new Person[0]).containsOnlyNulls();</code></pre>
+   *
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual array is {@code null}.
+   * @throws AssertionError if the actual array is empty or contains a non null element
+   * @since 2.9.0 / 3.9.0
+   */
+  @Override
+  public SELF containsOnlyNulls() {
+    arrays.assertContainsOnlyNulls(info, actual);
+    return myself;
+  }
+
   /**
    * An alias of {@link #containsOnlyElementsOf(Iterable)} : verifies that actual contains all elements of the
    * given {@code Iterable} and nothing else, <b>in any order</b>.

src/main/java/org/assertj/core/api/AtomicReferenceArrayAssert.java

@@ -22,7 +22,6 @@
 import static org.assertj.core.internal.CommonValidations.checkSubsequenceIsNotNull;
 import static org.assertj.core.util.Arrays.array;
 import static org.assertj.core.util.Arrays.isArray;
-import static org.assertj.core.util.Arrays.prepend;
 import static org.assertj.core.util.IterableUtil.toArray;
 import static org.assertj.core.util.Lists.newArrayList;
 import static org.assertj.core.util.Preconditions.checkNotNull;
@@ -328,6 +327,33 @@ public AtomicReferenceArrayAssert<T> containsOnlyElementsOf(Iterable<? extends T
     return containsOnly(toArray(iterable));
   }
 
+  /**
+   * Verifies that the actual AtomicReferenceArray contains only null elements and nothing else.
+   * <p>
+   * Example :
+   * <pre><code class='java'> // assertion will pass
+   * AtomicReferenceArray&lt;String&gt; items = new AtomicReferenceArray&lt;&gt;(new String[]{null, null, null});
+   * assertThat(items).containsOnlyNulls();
+   *
+   * // assertion will fail because items2 contains not null element
+   * AtomicReferenceArray&lt;String&gt; items2 = new AtomicReferenceArray&lt;&gt;(new String[]{null, null, "notNull"});
+   * assertThat(items2).containsOnlyNulls();
+   * 
+   * // assertion will fail since an empty array does not contain any element and therefore no null ones.
+   * AtomicReferenceArray&lt;String&gt; empty = new AtomicReferenceArray&lt;&gt;(new String[0]);
+   * assertThat(empty).containsOnlyNulls();</code></pre>
+   *
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual AtomicReferenceArray is {@code null}.
+   * @throws AssertionError if the actual AtomicReferenceArray is empty or contains non null elements.
+   * @since 2.9.0 / 3.9.0
+   */
+  @Override
+  public AtomicReferenceArrayAssert<T> containsOnlyNulls() {
+    arrays.assertContainsOnlyNulls(info, array);
+    return myself;
+  }
+
   /**
    * An alias of {@link #containsOnlyElementsOf(Iterable)} : verifies that actual contains all elements of the
    * given {@code Iterable} and nothing else, <b>in any order</b>.

src/main/java/org/assertj/core/api/ObjectEnumerableAssert.java

@@ -81,6 +81,29 @@ public interface ObjectEnumerableAssert<SELF extends ObjectEnumerableAssert<SELF
    */
   SELF containsOnly(@SuppressWarnings("unchecked") ELEMENT... values);
 
+  /**
+   * Verifies that the actual group contains only null elements and nothing else.
+   * <p>
+   * Example :
+   * <pre><code class='java'> // assertion will pass
+   * Iterable&lt;String&gt; items = Arrays.asList(null, null, null);
+   * assertThat(items).containsOnlyNulls();
+   *
+   * // assertion will fail because items2 contains a not null element
+   * Iterable&lt;String&gt; items2 = Arrays.asList(null, null, "notNull");
+   * assertThat(items2).containsOnlyNulls();
+   * 
+   * // assertion will fail since an empty iterable does not contain any element and therefore no null ones.
+   * Iterable&lt;String&gt; empty = new ArrayList&lt;&gt;();
+   * assertThat(empty).containsOnlyNulls();</code></pre>
+   *
+   * @return {@code this} assertion object.
+   * @throws AssertionError if the actual group is {@code null}.
+   * @throws AssertionError if the actual group is empty or contains non null elements.
+   * @since 2.9.0 / 3.9.0
+   */
+  SELF containsOnlyNulls();
+
   /**
    * Verifies that the actual group contains the given values only once.
    * <p>
@@ -491,7 +514,7 @@ public interface ObjectEnumerableAssert<SELF extends ObjectEnumerableAssert<SELF
    * @throws AssertionError if the actual group is {@code null}.
    * @throws AssertionError if the actual group does not end with the given sequence of objects.
    */
-  SELF endsWith(@SuppressWarnings("unchecked") ELEMENT[] sequence);
+  SELF endsWith(ELEMENT[] sequence);
 
   /**
    * Verifies that the actual group contains at least a null element.

src/main/java/org/assertj/core/error/ShouldContainOnlyNulls.java

@@ -0,0 +1,61 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2017 the original author or authors.
+ */
+package org.assertj.core.error;
+
+import static org.assertj.core.error.ShouldContainOnlyNulls.ErrorType.EMPTY;
+import static org.assertj.core.error.ShouldContainOnlyNulls.ErrorType.NON_NULL_ELEMENTS;
+
+/**
+ * Creates an error message indicating that an assertion that verifies a group of elements contains only null elements failed. A group
+ * of elements can be a collection or an array.
+ *
+ * @author Billy Yuan
+ */
+public class ShouldContainOnlyNulls extends BasicErrorMessageFactory {
+
+  /**
+   * Creates a new <code>{@link ShouldContainOnlyNulls}</code>.
+   * @param actual the actual value in the failed assertion.
+   * @param nonNullElements the values that are not null elements in the failed assertion.
+   * @return the created {@code ErrorMessageFactory}.
+   */
+  public static ErrorMessageFactory shouldContainOnlyNulls(Object actual) {
+    return new ShouldContainOnlyNulls(actual, EMPTY, null);
+  }
+
+  public static ErrorMessageFactory shouldContainOnlyNulls(Object actual, Iterable<?> nonNullElements) {
+    return new ShouldContainOnlyNulls(actual, NON_NULL_ELEMENTS, nonNullElements);
+  }
+
+  private ShouldContainOnlyNulls(Object actual, ErrorType errorType, Iterable<?> notExpected) {
+    super("%n" +
+          "Expecting:%n" +
+          "  <%s>%n" +
+          "to contain only null elements but " + describe(errorType),
+          actual, notExpected);
+  }
+
+  private static String describe(ErrorType errorType) {
+    switch (errorType) {
+    case EMPTY:
+      return "it was empty";
+    case NON_NULL_ELEMENTS:
+    default:
+      return "some elements were not:%n  <%s>";
+    }
+  }
+
+  public enum ErrorType {
+    EMPTY, NON_NULL_ELEMENTS
+  }
+}

src/main/java/org/assertj/core/internal/Arrays.java

@@ -41,6 +41,7 @@
 import static org.assertj.core.error.ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder;
 import static org.assertj.core.error.ShouldContainNull.shouldContainNull;
 import static org.assertj.core.error.ShouldContainOnly.shouldContainOnly;
+import static org.assertj.core.error.ShouldContainOnlyNulls.shouldContainOnlyNulls;
 import static org.assertj.core.error.ShouldContainSequence.shouldContainSequence;
 import static org.assertj.core.error.ShouldContainSubsequence.shouldContainSubsequence;
 import static org.assertj.core.error.ShouldContainsOnlyOnce.shouldContainsOnlyOnce;
@@ -214,6 +215,18 @@ void assertContainsOnly(AssertionInfo info, Failures failures, Object actual, Ob
                                                      comparisonStrategy));
   }
 
+  void assertContainsOnlyNulls(AssertionInfo info, Failures failures, Object[] actual) {
+    assertNotNull(info, actual);
+    // empty => no null elements => failure
+    if (actual.length == 0) throw failures.failure(info, shouldContainOnlyNulls(actual));
+    // look for any non null elements
+    List<Object> nonNullElements = new ArrayList<>();
+    for (Object element : actual) {
+      if (element != null) nonNullElements.add(element);
+    }
+    if (nonNullElements.size() > 0) throw failures.failure(info, shouldContainOnlyNulls(actual, nonNullElements));
+  }
+
   void assertContainsExactly(AssertionInfo info, Failures failures, Object actual, Object values) {
     if (commonChecks(info, actual, values)) return;
     assertIsArray(info, actual);

src/main/java/org/assertj/core/internal/Iterables.java

@@ -35,6 +35,7 @@
 import static org.assertj.core.error.ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder;
 import static org.assertj.core.error.ShouldContainNull.shouldContainNull;
 import static org.assertj.core.error.ShouldContainOnly.shouldContainOnly;
+import static org.assertj.core.error.ShouldContainOnlyNulls.shouldContainOnlyNulls;
 import static org.assertj.core.error.ShouldContainSequence.shouldContainSequence;
 import static org.assertj.core.error.ShouldContainSubsequence.shouldContainSubsequence;
 import static org.assertj.core.error.ShouldContainsOnlyOnce.shouldContainsOnlyOnce;
@@ -65,6 +66,7 @@
 import static org.assertj.core.util.Lists.newArrayList;
 import static org.assertj.core.util.Sets.newTreeSet;
 
+import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
@@ -304,6 +306,27 @@ public void assertContainsOnlyOnce(AssertionInfo info, Iterable<?> actual, Objec
     // assertion succeeded
   }
 
+  /**
+   * Asserts that the given {@code Iterable} contains only null elements and nothing else.
+   *
+   * @param info contains information about the assertion.
+   * @param actual the given {@code Iterable}.
+   * @throws AssertionError if the given {@code Iterable} is {@code null}.
+   * @throws AssertionError if the given {@code Iterable} does not contain at least a null element or if the given
+   *           {@code Iterable} contains values that are not null elements.
+   */
+  public void assertContainsOnlyNulls(AssertionInfo info, Iterable<?> actual) {
+    assertNotNull(info, actual);
+    // empty => no null elements => failure
+    if (sizeOf(actual) == 0) throw failures.failure(info, shouldContainOnlyNulls(actual));
+    // look for any non null elements
+    List<Object> nonNullElements = new ArrayList<>();
+    for (Object element : actual) {
+      if (element != null) nonNullElements.add(element);
+    }
+    if (nonNullElements.size() > 0) throw failures.failure(info, shouldContainOnlyNulls(actual, nonNullElements));
+  }
+
   /**
    * Verifies that the given <code>{@link Iterable}</code> contains the given sequence of objects, without any other
    * objects between them.
@@ -829,7 +852,7 @@ private <E> boolean conditionIsSatisfiedNTimes(Iterable<? extends E> actual, Con
                                                  int times) {
     List<E> satisfiesCondition = satisfiesCondition(actual, condition);
     return satisfiesCondition.size() == times;
-  }
+}
 
   /**
    * An alias method of {@link #assertAreAtLeast(AssertionInfo, Iterable, int, Condition)} to provide a richer fluent

src/main/java/org/assertj/core/internal/ObjectArrays.java

@@ -246,6 +246,19 @@ public void assertContainsOnlyOnce(AssertionInfo info, Object[] actual, Object[]
     arrays.assertContainsOnlyOnce(info, failures, actual, values);
   }
 
+  /**
+   * Asserts that the given array contains only null elements.
+   *
+   * @param info contains information about the assertion
+   * @param actual the given array
+   * @throws AssertionError if the given array is {@code null}.
+   * @throws AssertionError if the given array does not contain at least a null element
+   *           or contains values that are not null elements.
+   */
+  public void assertContainsOnlyNulls(AssertionInfo info, Object[] actual) {
+    arrays.assertContainsOnlyNulls(info, failures, actual);
+  }
+
   /**
    * Verifies that the given array contains the given sequence of objects, without any other objects between them.
    * 

src/test/java/org/assertj/core/api/atomic/referencearray/AtomicReferenceArrayAssert_containsOnlyNulls_Test.java

@@ -0,0 +1,35 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2017 the original author or authors.
+ */
+package org.assertj.core.api.atomic.referencearray;
+
+import org.assertj.core.api.AtomicReferenceArrayAssert;
+import org.assertj.core.api.AtomicReferenceArrayAssertBaseTest;
+
+import static org.mockito.Mockito.verify;
+
+/**
+ * Tests for <code>{@link AtomicReferenceArrayAssert#containsOnlyNulls()}</code>.
+ *
+ * @author Billy Yuan
+ */
+public class AtomicReferenceArrayAssert_containsOnlyNulls_Test extends AtomicReferenceArrayAssertBaseTest {
+  @Override
+  protected AtomicReferenceArrayAssert<Object> invoke_api_method() {
+    return assertions.containsOnlyNulls();
+  }
+
+  @Override
+  protected void verify_internal_effects() {
+    verify(arrays).assertContainsOnlyNulls(info(), internalArray());
+  }
+}

src/test/java/org/assertj/core/api/iterable/IterableAssert_containsOnlyNulls_Test.java

@@ -0,0 +1,36 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2017 the original author or authors.
+ */
+package org.assertj.core.api.iterable;
+
+import org.assertj.core.api.AbstractIterableAssert;
+import org.assertj.core.api.ConcreteIterableAssert;
+import org.assertj.core.api.IterableAssertBaseTest;
+
+import static org.mockito.Mockito.verify;
+
+/**
+ * Tests for <code>{@link AbstractIterableAssert#containsOnlyNulls()}</code>.
+ *
+ * @author Billy Yuan
+ */
+public class IterableAssert_containsOnlyNulls_Test extends IterableAssertBaseTest {
+  @Override
+  protected ConcreteIterableAssert<Object> invoke_api_method() {
+    return assertions.containsOnlyNulls();
+  }
+
+  @Override
+  protected void verify_internal_effects() {
+    verify(iterables).assertContainsOnlyNulls(getInfo(assertions), getActual(assertions));
+  }
+}