Add methods to check for size and empty collections

Author: uhafner

src/main/java/edu/hm/hafner/util/Ensure.java

@@ -22,7 +22,7 @@
  * </p>
  *
  * <p>
- *  Available checks:
+ * Available checks:
  * </p>
  * <ul>
  *      <li>Boolean assertions, e.g., {@code Ensure.that(condition).isTrue(); } </li>
@@ -33,7 +33,8 @@
  * </ul>
  *
  * @author Ullrich Hafner
- * @see <a href="http://se.ethz.ch/~meyer/publications/computer/contract.pdf"> Design by Contract (Meyer, Bertrand)</a>
+ * @see <a href="http://se.ethz.ch/~meyer/publications/computer/contract.pdf"> Design by Contract (Meyer,
+ *         Bertrand)</a>
  */
 public final class Ensure {
     /**
@@ -212,12 +213,78 @@ public IterableCondition(@CheckForNull final Iterable<?> value) {
          * that each element of the iterable is not {@code null}.
          *
          * @throws AssertionError
-         *         if the iterable is empty (or {@code null}), or at least one iterable element is {@code null}.
+         *         if the iterable is empty (or {@code null}), or at least one iterable element is {@code null}
          */
         public void isNotEmpty() {
             isNotEmpty("Iterable is empty or NULL");
         }
 
+        /**
+         * Ensures that the given iterable is not {@code null} but empty.
+         *
+         * @throws AssertionError
+         *         if the iterable is not empty (or {@code null})
+         */
+        public void isEmpty() {
+            isEmpty("Iterable is not empty or NULL");
+        }
+
+        /**
+         * Ensures that the given iterable is not {@code null} and contains the specified number of elements.
+         * Additionally, ensures that each element of the iterable is not {@code null}.
+         *
+         * @param expectedSize
+         *         the expected number of elements in the iterable
+         *
+         * @throws AssertionError
+         *         if the iterable does not contain the expected number of elements (or is {@code null}), or at least
+         *         one iterable element is {@code null}
+         */
+        @FormatMethod
+        public void hasSize(final int expectedSize) {
+            hasSize(expectedSize,
+                    "Iterable does not contain the expected number of elements. Actual: %s. Expected: %d",
+                    getValue(), expectedSize);
+        }
+
+        /**
+         * Ensures that the given iterable is not {@code null} and contains the specified number of elements.
+         * Additionally, ensures that each element of the iterable is not {@code null}.
+         *
+         * @param expectedSize
+         *         the expected number of elements in the iterable
+         * @param explanation
+         *         a {@link Formatter formatted message} explaining the assertion
+         * @param args
+         *         Arguments referenced by the format specifiers in the formatted explanation. If there are more
+         *         arguments than format specifiers, the extra arguments are ignored. The number of arguments is
+         *         variable and may be zero.
+         *
+         * @throws AssertionError
+         *         if the iterable does not contain the expected number of elements (or is {@code null}), or at least
+         *         one iterable element is {@code null}
+         */
+        @FormatMethod
+        public void hasSize(final int expectedSize, final String explanation, final Object... args) {
+            isNotNull(explanation, args);
+
+            var size = computeSize(explanation, args);
+            if (size != expectedSize) {
+                throwException(explanation, args);
+            }
+        }
+
+        private int computeSize(final String explanation, final Object... args) {
+            int size = 0;
+            for (Object object : getValue()) {
+                if (object == null) {
+                    throwException(explanation, args);
+                }
+                size++;
+            }
+            return size;
+        }
+
         /**
          * Ensures that the given iterable is not {@code null} and contains at least one element. Additionally, ensures
          * that each element of the iterable is not {@code null}.
@@ -230,20 +297,35 @@ public void isNotEmpty() {
          *         variable and may be zero.
          *
          * @throws AssertionError
-         *         if the iterable is empty (or {@code null}), or at least one iterable element is {@code null}.
+         *         if the iterable is empty (or {@code null}), or at least one iterable element is {@code null}
          */
         @FormatMethod
         public void isNotEmpty(final String explanation, final Object... args) {
             isNotNull(explanation, args);
 
-            if (getValue().iterator().hasNext()) {
-                for (Object object : getValue()) {
-                    if (object == null) {
-                        throwException(explanation, args);
-                    }
-                }
+            if (computeSize(explanation, args) == 0) {
+                throwException(explanation, args);
             }
-            else {
+        }
+
+        /**
+         * Ensures that the given iterable is not {@code null} but has no elements.
+         *
+         * @param explanation
+         *         a {@link Formatter formatted message} explaining the assertion
+         * @param args
+         *         Arguments referenced by the format specifiers in the formatted explanation. If there are more
+         *         arguments than format specifiers, the extra arguments are ignored. The number of arguments is
+         *         variable and may be zero.
+         *
+         * @throws AssertionError
+         *         if the iterable is not empty (or {@code null})
+         */
+        @FormatMethod
+        public void isEmpty(final String explanation, final Object... args) {
+            isNotNull(explanation, args);
+
+            if (computeSize(explanation, args) != 0) {
                 throwException(explanation, args);
             }
         }
@@ -363,12 +445,61 @@ public ArrayCondition(@CheckForNull final Object[] values) {
          * that each element of the array is not {@code null}.
          *
          * @throws AssertionError
-         *         if the array is empty (or {@code null}), or at least one array element is {@code null}.
+         *         if the array is empty (or {@code null}), or at least one array element is {@code null}
          */
         public void isNotEmpty() {
             isNotEmpty("Array is empty or NULL");
         }
 
+        /**
+         * Ensures that the given array is not {@code null} but empty.
+         *
+         * @throws AssertionError
+         *         if the array is not empty (or {@code null})
+         */
+        public void isEmpty() {
+            isEmpty("Array is not empty or NULL");
+        }
+
+        /**
+         * Ensures that the given array is not {@code null} and has the specified number of elements. Additionally,
+         * ensures that each element of the array is not {@code null}.
+         *
+         * @param expectedSize
+         *         the expected number of elements in the array
+         *
+         * @throws AssertionError
+         *         if the array does not contain the expected number of elements (or is {@code null}), or at least one
+         *         array element is {@code null}
+         */
+        public void hasSize(final int expectedSize) {
+            hasSize(expectedSize,
+                    "Array does not contain the expected number of elements. Actual: %s. Expected: %d",
+                    getValue().length, expectedSize);
+        }
+
+        /**
+         * Ensures that the given array is not {@code null} but empty.
+         *
+         * @param explanation
+         *         a {@link Formatter formatted message} explaining the assertion
+         * @param args
+         *         Arguments referenced by the format specifiers in the formatted explanation. If there are more
+         *         arguments than format specifiers, the extra arguments are ignored. The number of arguments is
+         *         variable and may be zero.
+         *
+         * @throws AssertionError
+         *         if the array is empty (or {@code null}), or at least one array element is {@code null}.
+         */
+        @FormatMethod
+        public void isEmpty(final String explanation, final Object... args) {
+            isNotNull(explanation, args);
+
+            if (getValue().length != 0) {
+                throwException(explanation, args);
+            }
+        }
+
         /**
          * Ensures that the given array is not {@code null} and contains at least one element. Additionally, ensures
          * that each element of the array is not {@code null}.
@@ -391,15 +522,45 @@ public void isNotEmpty(final String explanation, final Object... args) {
                 throwException(explanation, args);
             }
             else {
-                for (Object object : getValue()) {
-                    if (object == null) {
-                        throwException(explanation, args);
-                    }
-                }
+                doesNotContainNull(explanation, args);
+            }
+        }
+
+        /**
+         * Ensures that the given array is not {@code null} and contains the specified number of elements. Additionally,
+         * ensures that each element of the array is not {@code null}.
+         *
+         * @param expectedSize
+         *         the expected number of elements in the array
+         * @param explanation
+         *         a {@link Formatter formatted message} explaining the assertion
+         * @param args
+         *         Arguments referenced by the format specifiers in the formatted explanation. If there are more
+         *         arguments than format specifiers, the extra arguments are ignored. The number of arguments is
+         *         variable and may be zero.
+         *
+         * @throws AssertionError
+         *         if the array is empty (or {@code null}), or at least one array element is {@code null}.
+         */
+        @FormatMethod
+        public void hasSize(final int expectedSize, final String explanation, final Object... args) {
+            isNotNull(explanation, args);
+
+            if (getValue().length == expectedSize) {
+                doesNotContainNull(explanation, args);
+            }
+            else {
+                throwException(explanation, args);
             }
         }
 
-        // FIXME: add isEmpty() methods
+        private void doesNotContainNull(final String explanation, final Object[] args) {
+            for (Object object : getValue()) {
+                if (object == null) {
+                    throwException(explanation, args);
+                }
+            }
+        }
     }
 
     /**

src/test/java/edu/hm/hafner/util/EnsureTest.java

@@ -30,10 +30,15 @@ void shouldNotThrowExceptionIfContractIsValid() {
             Ensure.that("", "").isNotNull();
             Ensure.that(null, (Object) null).isNull();
             Ensure.that(new String[]{""}).isNotEmpty();
+            Ensure.that(new String[]{""}).hasSize(1);
+            Ensure.that(new String[0]).isEmpty();
+            Ensure.that(new String[0]).hasSize(0);
             Ensure.that(SOME_STRING).isNotEmpty();
             Ensure.that(SOME_STRING).isNotBlank();
             Ensure.that("").isInstanceOf(String.class);
+            Ensure.that(Set.of()).isEmpty();
             Ensure.that(Set.of("")).isNotEmpty();
+            Ensure.that(Set.of("")).hasSize(1);
             Ensure.that(Set.of("")).contains("");
             Ensure.that(Set.of("")).doesNotContain(SOME_STRING);
         }).doesNotThrowAnyException();
@@ -71,6 +76,20 @@ void shouldThrowExceptionIfContractIsViolated() {
                 .isInstanceOf(AssertionError.class);
         assertThatThrownBy(() -> Ensure.that(Set.of("")).doesNotContain(""))
                 .isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> Ensure.that(Set.of("")).isEmpty())
+                .isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> Ensure.that(Set.of()).isNotEmpty())
+                .isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> Ensure.that(Set.of("")).hasSize(0))
+                .isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> Ensure.that(Set.of("")).hasSize(2))
+                .isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> Ensure.that(new String[]{"not-empty"}).isEmpty())
+                .isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> Ensure.that(new String[]{"not-empty"}).hasSize(0))
+                .isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() -> Ensure.that(new String[]{"not-empty"}).hasSize(2))
+                .isInstanceOf(AssertionError.class);
     }
 
     /**
@@ -121,6 +140,8 @@ void shouldThrowExceptionIfEmpty() {
                 Ensure.that("").isNotEmpty(ERROR_MESSAGE)).isInstanceOf(AssertionError.class);
         assertThatThrownBy(() ->
                 Ensure.that(" ").isNotBlank(ERROR_MESSAGE)).isInstanceOf(AssertionError.class);
+        assertThatThrownBy(() ->
+                Ensure.that("").isNotBlank(ERROR_MESSAGE)).isInstanceOf(AssertionError.class);
         assertThatThrownBy(() ->
                 Ensure.that("").isInstanceOf(Integer.class, ERROR_MESSAGE)).isInstanceOf(AssertionError.class);
         assertThatThrownBy(() ->