From 17dd5dd22d9b68bf60c302833c8c33d3cb914ed3 Mon Sep 17 00:00:00 2001 From: Sam Brannen Date: Tue, 12 Jul 2016 16:36:30 +0200 Subject: [PATCH] Introduce Supplier support in Assert util Prior to this commit, utility methods in org.springframework.util.Assert accepted String arguments for custom error messages. Such Strings are evaluated (e.g., concatenated) eagerly, and for performance reasons, it was therefore not always possible to make use of these utility methods. Consequently, there are several places in the code base that "inline" identical functionality in order to lazily evaluate error message concatenation and avoid an unnecessary performance penalty. This leads to verbose code like the following. if (!contextPath.startsWith("/")) { throw new IllegalArgumentException("contextPath '" + contextPath + "' must start with '/'."); } if (contextPath.endsWith("/")) { throw new IllegalArgumentException("contextPath '" + contextPath + "' must not end with '/'."); } This commit addresses this shortcoming by introducing Supplier variants of all utility methods in org.springframework.util.Assert that allow custom error messages to be evaluated lazily via a lambda expression that is only evaluated if the assertion fails. This results in a simplification of the previous examples as follows. Assert.isTrue(contextPath.startsWith("/"), () -> "contextPath '" + contextPath + "' must start with '/'."); Assert.isTrue(!contextPath.endsWith("/"), () -> "contextPath '" + contextPath + "' must not end with '/'."); Issue: SPR-14450 --- .../java/org/springframework/util/Assert.java | 392 +++++++++--- .../org/springframework/util/AssertTests.java | 574 +++++++++++++++--- 2 files changed, 828 insertions(+), 138 deletions(-) diff --git a/spring-core/src/main/java/org/springframework/util/Assert.java b/spring-core/src/main/java/org/springframework/util/Assert.java index 76b45186be7..24d54d1fb4f 100644 --- a/spring-core/src/main/java/org/springframework/util/Assert.java +++ b/spring-core/src/main/java/org/springframework/util/Assert.java @@ -18,6 +18,7 @@ package org.springframework.util; import java.util.Collection; import java.util.Map; +import java.util.function.Supplier; /** * Assertion utility class that assists in validating arguments. @@ -56,12 +57,29 @@ import java.util.Map; public abstract class Assert { /** - * Assert a boolean expression, throwing {@code IllegalArgumentException} - * if the test result is {@code false}. + * Assert a boolean expression, throwing an {@code IllegalArgumentException} + * if the expression evaluates to {@code false}. + * 
+	 * Assert.isTrue(i > 0, () -> "The value '" + i + "' must be greater than zero");
+	 *
+ * @param expression a boolean expression + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if {@code expression} is {@code false} + */ + public static void isTrue(boolean expression, Supplier messageSupplier) { + if (!expression) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + + /** + * Assert a boolean expression, throwing an {@code IllegalArgumentException} + * if the expression evaluates to {@code false}. * 
Assert.isTrue(i > 0, "The value must be greater than zero");
* @param expression a boolean expression * @param message the exception message to use if the assertion fails - * @throws IllegalArgumentException if expression is {@code false} + * @throws IllegalArgumentException if {@code expression} is {@code false} */ public static void isTrue(boolean expression, String message) { if (!expression) { @@ -70,18 +88,34 @@ public abstract class Assert { } /** - * Assert a boolean expression, throwing {@code IllegalArgumentException} - * if the test result is {@code false}. + * Assert a boolean expression, throwing an {@code IllegalArgumentException} + * if the expression evaluates to {@code false}. * 
Assert.isTrue(i > 0);
* @param expression a boolean expression - * @throws IllegalArgumentException if expression is {@code false} + * @throws IllegalArgumentException if {@code expression} is {@code false} */ public static void isTrue(boolean expression) { isTrue(expression, "[Assertion failed] - this expression must be true"); } /** - * Assert that an object is {@code null} . + * Assert that an object is {@code null}. + * 
+	 * Assert.isNull(value, () -> "The value '" + value + "' must be null");
+	 *
+ * @param object the object to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if the object is not {@code null} + */ + public static void isNull(Object object, Supplier messageSupplier) { + if (object != null) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + + /** + * Assert that an object is {@code null}. * 
Assert.isNull(value, "The value must be null");
* @param object the object to check * @param message the exception message to use if the assertion fails @@ -94,7 +128,7 @@ public abstract class Assert { } /** - * Assert that an object is {@code null} . + * Assert that an object is {@code null}. * 
Assert.isNull(value);
* @param object the object to check * @throws IllegalArgumentException if the object is not {@code null} @@ -104,7 +138,23 @@ public abstract class Assert { } /** - * Assert that an object is not {@code null} . + * Assert that an object is not {@code null}. + * 
+	 * Assert.notNull(clazz, () -> "The class '" + clazz.getName() + "' must not be null");
+	 *
+ * @param object the object to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if the object is {@code null} + */ + public static void notNull(Object object, Supplier messageSupplier) { + if (object == null) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + + /** + * Assert that an object is not {@code null}. * 
Assert.notNull(clazz, "The class must not be null");
* @param object the object to check * @param message the exception message to use if the assertion fails @@ -117,7 +167,7 @@ public abstract class Assert { } /** - * Assert that an object is not {@code null} . + * Assert that an object is not {@code null}. * 
Assert.notNull(clazz);
* @param object the object to check * @throws IllegalArgumentException if the object is {@code null} @@ -126,6 +176,24 @@ public abstract class Assert { notNull(object, "[Assertion failed] - this argument is required; it must not be null"); } + /** + * Assert that the given String is not empty; that is, + * it must not be {@code null} and not the empty String. + * 
+	 * Assert.hasLength(name, () -> "Name for account '" + account.getId() + "' must not be empty");
+	 *
+ * @param text the String to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @see StringUtils#hasLength + * @throws IllegalArgumentException if the text is empty + */ + public static void hasLength(String text, Supplier messageSupplier) { + if (!StringUtils.hasLength(text)) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + /** * Assert that the given String is not empty; that is, * it must not be {@code null} and not the empty String. @@ -155,7 +223,25 @@ public abstract class Assert { } /** - * Assert that the given String has valid text content; that is, it must not + * Assert that the given String contains valid text content; that is, it must not + * be {@code null} and must contain at least one non-whitespace character. + * 
+	 * Assert.hasText(name, () -> "Name for account '" + account.getId() + "' must not be empty");
+	 *
+ * @param text the String to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @see StringUtils#hasText + * @throws IllegalArgumentException if the text does not contain valid text content + */ + public static void hasText(String text, Supplier messageSupplier) { + if (!StringUtils.hasText(text)) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + + /** + * Assert that the given String contains valid text content; that is, it must not * be {@code null} and must contain at least one non-whitespace character. * 
Assert.hasText(name, "'name' must not be empty");
* @param text the String to check @@ -170,7 +256,7 @@ public abstract class Assert { } /** - * Assert that the given String has valid text content; that is, it must not + * Assert that the given String contains valid text content; that is, it must not * be {@code null} and must contain at least one non-whitespace character. * 
Assert.hasText(name, "'name' must not be empty");
* @param text the String to check @@ -182,6 +268,24 @@ public abstract class Assert { "[Assertion failed] - this String argument must have text; it must not be null, empty, or blank"); } + /** + * Assert that the given text does not contain the given substring. + * 
+	 * Assert.doesNotContain(name, forbidden, () -> "Name must not contain '" + forbidden + "'");
+	 *
+ * @param textToSearch the text to search + * @param substring the substring to find within the text + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if the text contains the substring + */ + public static void doesNotContain(String textToSearch, String substring, Supplier messageSupplier) { + if (StringUtils.hasLength(textToSearch) && StringUtils.hasLength(substring) && + textToSearch.contains(substring)) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + /** * Assert that the given text does not contain the given substring. * 
Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
@@ -206,16 +310,33 @@ public abstract class Assert { */ public static void doesNotContain(String textToSearch, String substring) { doesNotContain(textToSearch, substring, - "[Assertion failed] - this String argument must not contain the substring [" + substring + "]"); + () -> "[Assertion failed] - this String argument must not contain the substring [" + substring + "]"); + } + + /** + * Assert that an array contains elements; that is, it must not be + * {@code null} and must contain at least one element. + * 
+	 * Assert.notEmpty(array, () -> "The " + arrayType + " array must contain elements");
+	 *
+ * @param array the array to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if the object array is {@code null} or contains no elements + */ + public static void notEmpty(Object[] array, Supplier messageSupplier) { + if (ObjectUtils.isEmpty(array)) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } } /** - * Assert that an array has elements; that is, it must not be - * {@code null} and must have at least one element. - * 
Assert.notEmpty(array, "The array must have elements");
+ * Assert that an array contains elements; that is, it must not be + * {@code null} and must contain at least one element. + * 
Assert.notEmpty(array, "The array must contain elements");
* @param array the array to check * @param message the exception message to use if the assertion fails - * @throws IllegalArgumentException if the object array is {@code null} or has no elements + * @throws IllegalArgumentException if the object array is {@code null} or contains no elements */ public static void notEmpty(Object[] array, String message) { if (ObjectUtils.isEmpty(array)) { @@ -224,20 +345,42 @@ public abstract class Assert { } /** - * Assert that an array has elements; that is, it must not be - * {@code null} and must have at least one element. + * Assert that an array contains elements; that is, it must not be + * {@code null} and must contain at least one element. * 
Assert.notEmpty(array);
* @param array the array to check - * @throws IllegalArgumentException if the object array is {@code null} or has no elements + * @throws IllegalArgumentException if the object array is {@code null} or + * contains no elements */ public static void notEmpty(Object[] array) { notEmpty(array, "[Assertion failed] - this array must not be empty: it must contain at least 1 element"); } /** - * Assert that an array has no null elements. - * Note: Does not complain if the array is empty! - * 
Assert.noNullElements(array, "The array must have non-null elements");
+ * Assert that an array contains no {@code null} elements. + *

Note: Does not complain if the array is empty! + * 

+	 * Assert.noNullElements(array, () -> "The " + arrayType + " array must contain non-null elements");
+	 *
+ * @param array the array to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if the object array contains a {@code null} element + */ + public static void noNullElements(Object[] array, Supplier messageSupplier) { + if (array != null) { + for (Object element : array) { + if (element == null) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + } + } + + /** + * Assert that an array contains no {@code null} elements. + *

Note: Does not complain if the array is empty! + * 

Assert.noNullElements(array, "The array must contain non-null elements");
* @param array the array to check * @param message the exception message to use if the assertion fails * @throws IllegalArgumentException if the object array contains a {@code null} element @@ -253,8 +396,8 @@ public abstract class Assert { } /** - * Assert that an array has no null elements. - * Note: Does not complain if the array is empty! + * Assert that an array contains no {@code null} elements. + *

Note: Does not complain if the array is empty! * 

Assert.noNullElements(array);
* @param array the array to check * @throws IllegalArgumentException if the object array contains a {@code null} element @@ -264,12 +407,31 @@ public abstract class Assert { } /** - * Assert that a collection has elements; that is, it must not be - * {@code null} and must have at least one element. - * 
Assert.notEmpty(collection, "Collection must have elements");
+ * Assert that a collection contains elements; that is, it must not be + * {@code null} and must contain at least one element. + * 
+	 * Assert.notEmpty(collection, () -> "The " + collectionType + " collection must contain elements");
+	 *
+ * @param collection the collection to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if the collection is {@code null} or + * contains no elements + */ + public static void notEmpty(Collection collection, Supplier messageSupplier) { + if (CollectionUtils.isEmpty(collection)) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + + /** + * Assert that a collection contains elements; that is, it must not be + * {@code null} and must contain at least one element. + * 
Assert.notEmpty(collection, "Collection must contain elements");
* @param collection the collection to check * @param message the exception message to use if the assertion fails - * @throws IllegalArgumentException if the collection is {@code null} or has no elements + * @throws IllegalArgumentException if the collection is {@code null} or + * contains no elements */ public static void notEmpty(Collection collection, String message) { if (CollectionUtils.isEmpty(collection)) { @@ -278,11 +440,12 @@ public abstract class Assert { } /** - * Assert that a collection has elements; that is, it must not be - * {@code null} and must have at least one element. - * 
Assert.notEmpty(collection, "Collection must have elements");
+ * Assert that a collection contains elements; that is, it must not be + * {@code null} and must contain at least one element. + * 
Assert.notEmpty(collection, "Collection must contain elements");
* @param collection the collection to check - * @throws IllegalArgumentException if the collection is {@code null} or has no elements + * @throws IllegalArgumentException if the collection is {@code null} or + * contains no elements */ public static void notEmpty(Collection collection) { notEmpty(collection, @@ -290,12 +453,29 @@ public abstract class Assert { } /** - * Assert that a Map has entries; that is, it must not be {@code null} - * and must have at least one entry. - * 
Assert.notEmpty(map, "Map must have entries");
+ * Assert that a Map contains entries; that is, it must not be {@code null} + * and must contain at least one entry. + * 
+	 * Assert.notEmpty(map, () -> "The " + mapType + " map must contain entries");
+	 *
+ * @param map the map to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalArgumentException if the map is {@code null} or contains no entries + */ + public static void notEmpty(Map map, Supplier messageSupplier) { + if (CollectionUtils.isEmpty(map)) { + throw new IllegalArgumentException(nullSafeGet(messageSupplier)); + } + } + + /** + * Assert that a Map contains entries; that is, it must not be {@code null} + * and must contain at least one entry. + * 
Assert.notEmpty(map, "Map must contain entries");
* @param map the map to check * @param message the exception message to use if the assertion fails - * @throws IllegalArgumentException if the map is {@code null} or has no entries + * @throws IllegalArgumentException if the map is {@code null} or contains no entries */ public static void notEmpty(Map map, String message) { if (CollectionUtils.isEmpty(map)) { @@ -304,11 +484,11 @@ public abstract class Assert { } /** - * Assert that a Map has entries; that is, it must not be {@code null} - * and must have at least one entry. + * Assert that a Map contains entries; that is, it must not be {@code null} + * and must contain at least one entry. * 
Assert.notEmpty(map);
* @param map the map to check - * @throws IllegalArgumentException if the map is {@code null} or has no entries + * @throws IllegalArgumentException if the map is {@code null} or contains no entries */ public static void notEmpty(Map map) { notEmpty(map, "[Assertion failed] - this map must not be empty; it must contain at least one entry"); @@ -317,37 +497,61 @@ public abstract class Assert { /** * Assert that the provided object is an instance of the provided class. * 
Assert.instanceOf(Foo.class, foo);
- * @param clazz the required class + * @param type the type to check against * @param obj the object to check - * @throws IllegalArgumentException if the object is not an instance of clazz + * @throws IllegalArgumentException if the object is not an instance of type * @see Class#isInstance */ - public static void isInstanceOf(Class clazz, Object obj) { - isInstanceOf(clazz, obj, ""); + public static void isInstanceOf(Class type, Object obj) { + isInstanceOf(type, obj, ""); } /** * Assert that the provided object is an instance of the provided class. - * 
Assert.instanceOf(Foo.class, foo);
+ * 
+	 * Assert.instanceOf(Foo.class, foo, () -> "Processing " + Foo.class.getSimpleName() + ":");
+	 *
+ * @param type the type to check against + * @param obj the object to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails; the message will be prepended to the message generated + * by this method in order to provide further context. It should normally end + * in ":" or "." so that the generated message looks OK when appended to it. + * @throws IllegalArgumentException if the object is not an instance of type + * @see Class#isInstance + */ + public static void isInstanceOf(Class type, Object obj, Supplier messageSupplier) { + notNull(type, "Type to check against must not be null"); + if (!type.isInstance(obj)) { + isInstanceCheckFailed(type, obj, nullSafeGet(messageSupplier)); + } + } + + /** + * Assert that the provided object is an instance of the provided class. + * 
Assert.instanceOf(Foo.class, foo, "Processing Foo:");
* @param type the type to check against * @param obj the object to check - * @param message a message which will be prepended to the message produced by - * the function itself, and which may be used to provide context. It should - * normally end in ":" or "." so that the generated message looks OK when - * appended to it. - * @throws IllegalArgumentException if the object is not an instance of clazz + * @param message a message which will be prepended to the message generated + * by this method in order to provide further context. It should normally end + * in ":" or "." so that the generated message looks OK when appended to it. + * @throws IllegalArgumentException if the object is not an instance of type * @see Class#isInstance */ public static void isInstanceOf(Class type, Object obj, String message) { notNull(type, "Type to check against must not be null"); if (!type.isInstance(obj)) { - throw new IllegalArgumentException( - (StringUtils.hasLength(message) ? message + " " : "") + - "Object of class [" + (obj != null ? obj.getClass().getName() : "null") + - "] must be an instance of " + type); + isInstanceCheckFailed(type, obj, message); } } + private static void isInstanceCheckFailed(Class type, Object obj, String message) { + throw new IllegalArgumentException( + (StringUtils.hasLength(message) ? message + " " : "") + + "Object of class [" + (obj != null ? obj.getClass().getName() : "null") + + "] must be an instance of " + type); + } + /** * Assert that {@code superType.isAssignableFrom(subType)} is {@code true}. * 
Assert.isAssignable(Number.class, myClass);
@@ -359,33 +563,77 @@ public abstract class Assert { isAssignable(superType, subType, ""); } + /** + * Assert that {@code superType.isAssignableFrom(subType)} is {@code true}. + * 
+	 * Assert.isAssignable(Number.class, myClass, () -> "Processing " + myClass.getSimpleName() + ":");
+	 *
+ * @param superType the super type to check against + * @param subType the sub type to check + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails; the message will be prepended to the message generated + * by this method in order to provide further context. It should normally end + * in ":" or "." so that the generated message looks OK when appended to it. + * @throws IllegalArgumentException if the classes are not assignable + */ + public static void isAssignable(Class superType, Class subType, Supplier messageSupplier) { + notNull(superType, "Super type to check against must not be null"); + if (subType == null || !superType.isAssignableFrom(subType)) { + isAssignableCheckFailed(superType, subType, nullSafeGet(messageSupplier)); + } + } + /** * Assert that {@code superType.isAssignableFrom(subType)} is {@code true}. * 
Assert.isAssignable(Number.class, myClass);
* @param superType the super type to check against * @param subType the sub type to check - * @param message a message which will be prepended to the message produced by - * the function itself, and which may be used to provide context. It should - * normally end in ":" or "." so that the generated message looks OK when - * appended to it. + * @param message a message which will be prepended to the message generated + * by this method in order to provide further context. It should normally end + * in ":" or "." so that the generated message looks OK when appended to it. * @throws IllegalArgumentException if the classes are not assignable */ public static void isAssignable(Class superType, Class subType, String message) { - notNull(superType, "Type to check against must not be null"); + notNull(superType, "Super type to check against must not be null"); if (subType == null || !superType.isAssignableFrom(subType)) { - throw new IllegalArgumentException((StringUtils.hasLength(message) ? message + " " : "") + - subType + " is not assignable to " + superType); + isAssignableCheckFailed(superType, subType, message); } } + private static void isAssignableCheckFailed(Class superType, Class subType, String message) { + throw new IllegalArgumentException((StringUtils.hasLength(message) ? message + " " : "") + + subType + " is not assignable to " + superType); + } + /** - * Assert a boolean expression, throwing {@code IllegalStateException} - * if the test result is {@code false}. Call isTrue if you wish to - * throw IllegalArgumentException on an assertion failure. + * Assert a boolean expression, throwing an {@code IllegalStateException} + * if the expression evaluates to {@code false}. + *

Call {@link #isTrue} if you wish to throw an {@code IllegalArgumentException} + * on an assertion failure. + * 

+	 * Assert.state(id == null,
+	 *     () -> "ID for " + entity.getName() + " must not already be initialized");
+	 *
+ * @param expression a boolean expression + * @param messageSupplier a supplier for the exception message to use if the + * assertion fails + * @throws IllegalStateException if {@code expression} is {@code false} + */ + public static void state(boolean expression, Supplier messageSupplier) { + if (!expression) { + throw new IllegalStateException(nullSafeGet(messageSupplier)); + } + } + + /** + * Assert a boolean expression, throwing an {@code IllegalStateException} + * if the expression evaluates to {@code false}. + *

Call {@link #isTrue} if you wish to throw an {@code IllegalArgumentException} + * on an assertion failure. * 

Assert.state(id == null, "The id property must not already be initialized");
* @param expression a boolean expression * @param message the exception message to use if the assertion fails - * @throws IllegalStateException if expression is {@code false} + * @throws IllegalStateException if {@code expression} is {@code false} */ public static void state(boolean expression, String message) { if (!expression) { @@ -394,16 +642,20 @@ public abstract class Assert { } /** - * Assert a boolean expression, throwing {@link IllegalStateException} - * if the test result is {@code false}. - *

Call {@link #isTrue(boolean)} if you wish to - * throw {@link IllegalArgumentException} on an assertion failure. + * Assert a boolean expression, throwing an {@link IllegalStateException} + * if the expression evaluates to {@code false}. + *

Call {@link #isTrue} if you wish to throw an {@code IllegalArgumentException} + * on an assertion failure. * 

Assert.state(id == null);
* @param expression a boolean expression - * @throws IllegalStateException if the supplied expression is {@code false} + * @throws IllegalStateException if {@code expression} is {@code false} */ public static void state(boolean expression) { state(expression, "[Assertion failed] - this state invariant must be true"); } + private static String nullSafeGet(Supplier messageSupplier) { + return (messageSupplier != null ? messageSupplier.get() : null); + } + } diff --git a/spring-core/src/test/java/org/springframework/util/AssertTests.java b/spring-core/src/test/java/org/springframework/util/AssertTests.java index f547e03a592..8da0f6a2536 100644 --- a/spring-core/src/test/java/org/springframework/util/AssertTests.java +++ b/spring-core/src/test/java/org/springframework/util/AssertTests.java @@ -16,18 +16,17 @@ package org.springframework.util; -import java.util.ArrayList; import java.util.Collection; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; import java.util.Map; -import java.util.Set; +import java.util.function.Supplier; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; +import static java.util.Collections.*; +import static org.hamcrest.CoreMatchers.*; + /** * Unit tests for the {@link Assert} class. * @@ -40,142 +39,581 @@ import org.junit.rules.ExpectedException; public class AssertTests { @Rule - public ExpectedException thrown = ExpectedException.none(); + public final ExpectedException thrown = ExpectedException.none(); @Test - public void instanceOf() { - Assert.isInstanceOf(HashSet.class, new HashSet<>()); + public void isTrue() { + Assert.isTrue(true); } - @Test(expected = IllegalArgumentException.class) - public void instanceOfWithTypeMismatch() { - Assert.isInstanceOf(HashMap.class, new HashSet<>()); + @Test + public void isTrueWithFalseExpression() { + thrown.expect(IllegalArgumentException.class); + Assert.isTrue(false); } @Test - public void instanceOfNoMessage() throws Exception { - thrown.expect(IllegalArgumentException.class); - thrown.expectMessage("Object of class [java.lang.Object] must be an instance " + - "of interface java.util.Set"); - Assert.isInstanceOf(Set.class, new Object(), null); + public void isTrueWithMessageSupplier() { + Assert.isTrue(true, () -> "enigma"); } @Test - public void instanceOfMessage() throws Exception { + public void isTrueWithFalseAndMessageSupplier() { thrown.expect(IllegalArgumentException.class); - thrown.expectMessage("Custom message. Object of class [java.lang.Object] must " + - "be an instance of interface java.util.Set"); - Assert.isInstanceOf(Set.class, new Object(), "Custom message."); + thrown.expectMessage("enigma"); + Assert.isTrue(false, () -> "enigma"); } @Test - public void isNullDoesNotThrowExceptionIfArgumentIsNullWithMessage() { - Assert.isNull(null, "Bla"); + public void isTrueWithFalseAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.isTrue(false, (Supplier) null); } @Test - public void isNullDoesNotThrowExceptionIfArgumentIsNull() { + public void isNull() { Assert.isNull(null); } - @Test(expected = IllegalArgumentException.class) - public void isNullThrowsExceptionIfArgumentIsNotNull() { + @Test + public void isNullWithMessage() { + Assert.isNull(null, "Bla"); + } + + @Test + public void isNullWithNonNullObject() { + thrown.expect(IllegalArgumentException.class); Assert.isNull(new Object()); } - @Test(expected = IllegalArgumentException.class) - public void isTrueWithFalseExpressionThrowsException() throws Exception { - Assert.isTrue(false); + @Test + public void isNullWithMessageSupplier() { + Assert.isNull(null, () -> "enigma"); } @Test - public void isTrueWithTrueExpressionSunnyDay() throws Exception { - Assert.isTrue(true); + public void isNullWithNonNullObjectAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.isNull("foo", () -> "enigma"); } - @Test(expected = IllegalArgumentException.class) - public void testHasLengthWithNullStringThrowsException() throws Exception { - Assert.hasLength(null); + @Test + public void isNullWithNonNullObjectAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.isNull("foo", (Supplier) null); } - @Test(expected = IllegalArgumentException.class) - public void hasLengthWithEmptyStringThrowsException() throws Exception { - Assert.hasLength(""); + @Test + public void notNull() { + Assert.notNull("foo"); } @Test - public void hasLengthWithWhitespaceOnlyStringDoesNotThrowException() throws Exception { - Assert.hasLength("\t "); + public void notNullWithMessageSupplier() { + Assert.notNull("foo", () -> "enigma"); + } + + @Test + public void notNullWithNullAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.notNull(null, () -> "enigma"); + } + + @Test + public void notNullWithNullAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.notNull(null, (Supplier) null); } @Test - public void hasLengthSunnyDay() throws Exception { + public void hasLength() { Assert.hasLength("I Heart ..."); } @Test - public void doesNotContainWithNullSearchStringDoesNotThrowException() throws Exception { + public void hasLengthWithWhitespaceOnly() { + Assert.hasLength("\t "); + } + + @Test + public void hasLengthWithEmptyString() { + thrown.expect(IllegalArgumentException.class); + Assert.hasLength(""); + } + + @Test + public void hasLengthWithNull() { + thrown.expect(IllegalArgumentException.class); + Assert.hasLength(null); + } + + @Test + public void hasLengthWithMessageSupplier() { + Assert.hasLength("foo", () -> "enigma"); + } + + @Test + public void hasLengthWithWhitespaceOnlyAndMessageSupplier() { + Assert.hasLength("\t", () -> "enigma"); + } + + @Test + public void hasLengthWithEmptyStringAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasLength("", () -> "enigma"); + } + + @Test + public void hasLengthWithNullAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasLength(null, () -> "enigma"); + } + + @Test + public void hasLengthWithNullAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.hasLength(null, (Supplier) null); + } + + @Test + public void hasText() { + Assert.hasText("foo"); + } + + @Test + public void hasTextWithWhitespaceOnly() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasText("\t ", "enigma"); + } + + @Test + public void hasTextWithEmptyString() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasText("", "enigma"); + } + + @Test + public void hasTextWithNullAndMessage() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasText(null, "enigma"); + } + + @Test + public void hasTextWithMessageSupplier() { + Assert.hasText("foo", () -> "enigma"); + } + + @Test + public void hasTextWithWhitespaceOnlyAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasText("\t ", () -> "enigma"); + } + + @Test + public void hasTextWithEmptyStringAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasText("", () -> "enigma"); + } + + @Test + public void hasTextWithNullAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.hasText(null, () -> "enigma"); + } + + @Test + public void hasTextWithNullAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.hasText(null, (Supplier) null); + } + + @Test + public void doesNotContainWithNullSearchString() { Assert.doesNotContain(null, "rod"); } @Test - public void doesNotContainWithNullSubstringDoesNotThrowException() throws Exception { - Assert.doesNotContain("A cool chick's name is Brod. ", null); + public void doesNotContainWithNullSubstring() { + Assert.doesNotContain("A cool chick's name is Brod.", null); + } + + @Test + public void doesNotContainWithEmptySubstring() { + Assert.doesNotContain("A cool chick's name is Brod.", ""); + } + + @Test + public void doesNotContainWithNullSearchStringAndNullSubstringAndMessage() { + Assert.doesNotContain(null, null, "enigma"); + } + + @Test + public void doesNotContainWithMessageSupplier() { + Assert.doesNotContain("foo", "bar", () -> "enigma"); + } + + @Test + public void doesNotContainWithNullSearchStringAndMessageSupplier() { + Assert.doesNotContain(null, "bar", () -> "enigma"); + } + + @Test + public void doesNotContainWithNullSubstringAndMessageSupplier() { + Assert.doesNotContain("foo", null, () -> "enigma"); + } + + @Test + public void doesNotContainWithNullSearchStringAndNullSubstringAndMessageSupplier() { + Assert.doesNotContain(null, null, () -> "enigma"); + } + + @Test + public void doesNotContainWithSubstringPresentInSearchStringAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.doesNotContain("1234", "23", () -> "enigma"); + } + + @Test + public void doesNotContainWithNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.doesNotContain("1234", "23", (Supplier) null); + } + + @Test + public void notEmptyArray() { + Assert.notEmpty(new String[] { "1234" }); + } + + @Test + public void notEmptyArrayWithMessageSupplier() { + Assert.notEmpty(new String[] { "1234" }, () -> "enigma"); + } + + @Test + public void notEmptyArrayWithEmptyArrayAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.notEmpty(new String[] {}, () -> "enigma"); + } + + @Test + public void notEmptyArrayWithNullArrayAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.notEmpty((Object[]) null, () -> "enigma"); + } + + @Test + public void notEmptyArrayWithEmptyArrayAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.notEmpty(new String[] {}, (Supplier) null); + } + + @Test + public void noNullElements() { + Assert.noNullElements(new String[] { "1234" }, "enigma"); + } + + @Test + public void noNullElementsWithEmptyArray() { + Assert.noNullElements(new String[] {}, "enigma"); + } + + @Test + public void noNullElementsWithMessageSupplier() { + Assert.noNullElements(new String[] { "1234" }, () -> "enigma"); + } + + @Test + public void noNullElementsWithEmptyArrayAndMessageSupplier() { + Assert.noNullElements(new String[] {}, () -> "enigma"); + } + + @Test + public void noNullElementsWithNullArrayAndMessageSupplier() { + Assert.noNullElements((Object[]) null, () -> "enigma"); + } + + @Test + public void noNullElementsWithNullElementsAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.noNullElements(new String[] { "foo", null, "bar" }, () -> "enigma"); + } + + @Test + public void noNullElementsWithNullElementsAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.noNullElements(new String[] { "foo", null, "bar" }, (Supplier) null); } @Test - public void doesNotContainWithEmptySubstringDoesNotThrowException() throws Exception { - Assert.doesNotContain("A cool chick's name is Brod. ", ""); + public void notEmptyCollection() { + Assert.notEmpty(singletonList("foo")); } - @Test(expected = IllegalArgumentException.class) - public void assertNotEmptyWithNullCollectionThrowsException() throws Exception { + @Test + public void notEmptyCollectionWithEmptyCollection() { + thrown.expect(IllegalArgumentException.class); + Assert.notEmpty(emptyList()); + } + + @Test + public void notEmptyCollectionWithNullCollection() { + thrown.expect(IllegalArgumentException.class); Assert.notEmpty((Collection) null); } - @Test(expected = IllegalArgumentException.class) - public void assertNotEmptyWithEmptyCollectionThrowsException() throws Exception { - Assert.notEmpty(new ArrayList<>()); + @Test + public void notEmptyCollectionWithMessageSupplier() { + Assert.notEmpty(singletonList("foo"), () -> "enigma"); + } + + @Test + public void notEmptyCollectionWithEmptyCollectionAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.notEmpty(emptyList(), () -> "enigma"); + } + + @Test + public void notEmptyCollectionWithNullCollectionAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.notEmpty((Collection) null, () -> "enigma"); + } + + @Test + public void notEmptyCollectionWithEmptyCollectionAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.notEmpty(emptyList(), (Supplier) null); } @Test - public void assertNotEmptyWithCollectionSunnyDay() throws Exception { - List collection = new ArrayList<>(); - collection.add(""); - Assert.notEmpty(collection); + public void notEmptyMap() { + Assert.notEmpty(singletonMap("foo", "bar")); } - @Test(expected = IllegalArgumentException.class) - public void assertNotEmptyWithNullMapThrowsException() throws Exception { + @Test + public void notEmptyMapWithNullMap() { + thrown.expect(IllegalArgumentException.class); Assert.notEmpty((Map) null); } - @Test(expected = IllegalArgumentException.class) - public void assertNotEmptyWithEmptyMapThrowsException() throws Exception { - Assert.notEmpty(new HashMap<>()); + @Test + public void notEmptyMapWithEmptyMap() { + thrown.expect(IllegalArgumentException.class); + Assert.notEmpty(emptyMap()); + } + + @Test + public void notEmptyMapWithMessageSupplier() { + Assert.notEmpty(singletonMap("foo", "bar"), () -> "enigma"); + } + + @Test + public void notEmptyMapWithEmptyMapAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.notEmpty(emptyMap(), () -> "enigma"); + } + + @Test + public void notEmptyMapWithNullMapAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma"); + Assert.notEmpty((Map) null, () -> "enigma"); + } + + @Test + public void notEmptyMapWithEmptyMapAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(equalTo(null)); + Assert.notEmpty(emptyMap(), (Supplier) null); + } + + @Test + public void isInstanceOf() { + Assert.isInstanceOf(String.class, "foo"); } @Test - public void assertNotEmptyWithMapSunnyDay() throws Exception { - Map map = new HashMap<>(); - map.put("", ""); - Assert.notEmpty(map); + public void isInstanceOfWithNullType() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Type to check against must not be null"); + Assert.isInstanceOf(null, "foo"); } - @Test(expected = IllegalArgumentException.class) - public void isInstanceofClassWithNullInstanceThrowsException() throws Exception { + @Test + public void isInstanceOfWithNullInstance() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Object of class [null] must be an instance of class java.lang.String"); Assert.isInstanceOf(String.class, null); } - @Test(expected = IllegalStateException.class) - public void stateWithFalseExpressionThrowsException() throws Exception { - Assert.state(false); + @Test + public void isInstanceOfWithTypeMismatchAndNullMessage() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Object of class [java.lang.Long] must be an instance of class java.lang.String"); + Assert.isInstanceOf(String.class, 42L, (String) null); } @Test - public void stateWithTrueExpressionSunnyDay() throws Exception { + public void isInstanceOfWithTypeMismatchAndCustomMessage() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage( + "Custom message. Object of class [java.lang.Long] must be an instance of class java.lang.String"); + Assert.isInstanceOf(String.class, 42L, "Custom message."); + } + + @Test + public void isInstanceOfWithMessageSupplier() { + Assert.isInstanceOf(String.class, "foo", () -> "enigma"); + } + + @Test + public void isInstanceOfWithNullTypeAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Type to check against must not be null"); + Assert.isInstanceOf(null, "foo", () -> "enigma"); + } + + @Test + public void isInstanceOfWithNullInstanceAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma: Object of class [null] must be an instance of class java.lang.String"); + Assert.isInstanceOf(String.class, null, () -> "enigma:"); + } + + @Test + public void isInstanceOfWithTypeMismatchAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Object of class [java.lang.Long] must be an instance of class java.lang.String"); + Assert.isInstanceOf(String.class, 42L, (Supplier) null); + } + + @Test + public void isInstanceOfWithTypeMismatchAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma: Object of class [java.lang.Long] must be an instance of class java.lang.String"); + Assert.isInstanceOf(String.class, 42L, () -> "enigma:"); + } + + @Test + public void isAssignable() { + Assert.isAssignable(Number.class, Integer.class); + } + + @Test + public void isAssignableWithNullSupertype() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Super type to check against must not be null"); + Assert.isAssignable(null, Integer.class); + } + + @Test + public void isAssignableWithNullSubtype() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("null is not assignable to class java.lang.Integer"); + Assert.isAssignable(Integer.class, null); + } + + @Test + public void isAssignableWithTypeMismatchAndNullMessage() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("class java.lang.Integer is not assignable to class java.lang.String"); + Assert.isAssignable(String.class, Integer.class, (String) null); + } + + @Test + public void isAssignableWithTypeMismatchAndCustomMessage() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma: class java.lang.Integer is not assignable to class java.lang.String"); + Assert.isAssignable(String.class, Integer.class, "enigma:"); + } + + @Test + public void isAssignableWithMessageSupplier() { + Assert.isAssignable(Number.class, Integer.class, () -> "enigma"); + } + + @Test + public void isAssignableWithNullSupertypeAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Super type to check against must not be null"); + Assert.isAssignable(null, Integer.class, () -> "enigma"); + } + + @Test + public void isAssignableWithNullSubtypeAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma: null is not assignable to class java.lang.Integer"); + Assert.isAssignable(Integer.class, null, () -> "enigma:"); + } + + @Test + public void isAssignableWithTypeMismatchAndNullMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("class java.lang.Integer is not assignable to class java.lang.String"); + Assert.isAssignable(String.class, Integer.class, (Supplier) null); + } + + @Test + public void isAssignableWithTypeMismatchAndMessageSupplier() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("enigma: class java.lang.Integer is not assignable to class java.lang.String"); + Assert.isAssignable(String.class, Integer.class, () -> "enigma:"); + } + + @Test + public void state() { Assert.state(true); } + @Test + public void stateWithFalseExpression() { + thrown.expect(IllegalStateException.class); + Assert.state(false); + } + + @Test + public void stateWithMessageSupplier() { + Assert.state(true, () -> "enigma"); + } + + @Test + public void stateWithFalseExpressionAndMessageSupplier() { + thrown.expect(IllegalStateException.class); + thrown.expectMessage("enigma"); + Assert.state(false, () -> "enigma"); + } + + @Test + public void stateWithFalseExpressionAndNullMessageSupplier() { + thrown.expect(IllegalStateException.class); + thrown.expectMessage(equalTo(null)); + Assert.state(false, (Supplier) null); + } + }