Introduce Supplier<String> 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<String>
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

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}.
+	 * <pre class="code">
+	 * Assert.isTrue(i &gt; 0, () -&gt; "The value '" + i + "' must be greater than zero");
+	 * </pre>
+	 * @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<String> messageSupplier) {
+		if (!expression) {
+			throw new IllegalArgumentException(nullSafeGet(messageSupplier));
+		}
+	}
+
+	/**
+	 * Assert a boolean expression, throwing an {@code IllegalArgumentException}
+	 * if the expression evaluates to {@code false}.
 	 * <pre class="code">Assert.isTrue(i &gt; 0, "The value must be greater than zero");</pre>
 	 * @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}.
 	 * <pre class="code">Assert.isTrue(i &gt; 0);</pre>
 	 * @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}.
+	 * <pre class="code">
+	 * Assert.isNull(value, () -&gt; "The value '" + value + "' must be null");
+	 * </pre>
+	 * @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<String> messageSupplier) {
+		if (object != null) {
+			throw new IllegalArgumentException(nullSafeGet(messageSupplier));
+		}
+	}
+
+	/**
+	 * Assert that an object is {@code null}.
 	 * <pre class="code">Assert.isNull(value, "The value must be null");</pre>
 	 * @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}.
 	 * <pre class="code">Assert.isNull(value);</pre>
 	 * @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}.
+	 * <pre class="code">
+	 * Assert.notNull(clazz, () -&gt; "The class '" + clazz.getName() + "' must not be null");
+	 * </pre>
+	 * @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<String> messageSupplier) {
+		if (object == null) {
+			throw new IllegalArgumentException(nullSafeGet(messageSupplier));
+		}
+	}
+
+	/**
+	 * Assert that an object is not {@code null}.
 	 * <pre class="code">Assert.notNull(clazz, "The class must not be null");</pre>
 	 * @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}.
 	 * <pre class="code">Assert.notNull(clazz);</pre>
 	 * @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.
+	 * <pre class="code">
+	 * Assert.hasLength(name, () -&gt; "Name for account '" + account.getId() + "' must not be empty");
+	 * </pre>
+	 * @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<String> 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.
+	 * <pre class="code">
+	 * Assert.hasText(name, () -&gt; "Name for account '" + account.getId() + "' must not be empty");
+	 * </pre>
+	 * @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<String> 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.
 	 * <pre class="code">Assert.hasText(name, "'name' must not be empty");</pre>
 	 * @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.
 	 * <pre class="code">Assert.hasText(name, "'name' must not be empty");</pre>
 	 * @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.
+	 * <pre class="code">
+	 * Assert.doesNotContain(name, forbidden, () -&gt; "Name must not contain '" + forbidden + "'");
+	 * </pre>
+	 * @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<String> 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.
 	 * <pre class="code">Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");</pre>
@@ -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.
+	 * <pre class="code">
+	 * Assert.notEmpty(array, () -&gt; "The " + arrayType + " array must contain elements");
+	 * </pre>
+	 * @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<String> 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.
-	 * <pre class="code">Assert.notEmpty(array, "The array must have elements");</pre>
+	 * Assert that an array contains elements; that is, it must not be
+	 * {@code null} and must contain at least one element.
+	 * <pre class="code">Assert.notEmpty(array, "The array must contain elements");</pre>
 	 * @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.
 	 * <pre class="code">Assert.notEmpty(array);</pre>
 	 * @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!
-	 * <pre class="code">Assert.noNullElements(array, "The array must have non-null elements");</pre>
+	 * Assert that an array contains no {@code null} elements.
+	 * <p>Note: Does not complain if the array is empty!
+	 * <pre class="code">
+	 * Assert.noNullElements(array, () -&gt; "The " + arrayType + " array must contain non-null elements");
+	 * </pre>
+	 * @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<String> 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.
+	 * <p>Note: Does not complain if the array is empty!
+	 * <pre class="code">Assert.noNullElements(array, "The array must contain non-null elements");</pre>
 	 * @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.
+	 * <p>Note: Does not complain if the array is empty!
 	 * <pre class="code">Assert.noNullElements(array);</pre>
 	 * @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.
-	 * <pre class="code">Assert.notEmpty(collection, "Collection must have elements");</pre>
+	 * Assert that a collection contains elements; that is, it must not be
+	 * {@code null} and must contain at least one element.
+	 * <pre class="code">
+	 * Assert.notEmpty(collection, () -&gt; "The " + collectionType + " collection must contain elements");
+	 * </pre>
+	 * @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<String> 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.
+	 * <pre class="code">Assert.notEmpty(collection, "Collection must contain elements");</pre>
 	 * @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.
-	 * <pre class="code">Assert.notEmpty(collection, "Collection must have elements");</pre>
+	 * Assert that a collection contains elements; that is, it must not be
+	 * {@code null} and must contain at least one element.
+	 * <pre class="code">Assert.notEmpty(collection, "Collection must contain elements");</pre>
 	 * @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.
-	 * <pre class="code">Assert.notEmpty(map, "Map must have entries");</pre>
+	 * Assert that a Map contains entries; that is, it must not be {@code null}
+	 * and must contain at least one entry.
+	 * <pre class="code">
+	 * Assert.notEmpty(map, () -&gt; "The " + mapType + " map must contain entries");
+	 * </pre>
+	 * @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<String> 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.
+	 * <pre class="code">Assert.notEmpty(map, "Map must contain entries");</pre>
 	 * @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.
 	 * <pre class="code">Assert.notEmpty(map);</pre>
 	 * @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.
 	 * <pre class="code">Assert.instanceOf(Foo.class, foo);</pre>
-	 * @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.
-	 * <pre class="code">Assert.instanceOf(Foo.class, foo);</pre>
+	 * <pre class="code">
+	 * Assert.instanceOf(Foo.class, foo, () -&gt; "Processing " + Foo.class.getSimpleName() + ":");
+	 * </pre>
+	 * @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<String> 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.
+	 * <pre class="code">Assert.instanceOf(Foo.class, foo, "Processing Foo:");</pre>
 	 * @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}.
 	 * <pre class="code">Assert.isAssignable(Number.class, myClass);</pre>
@@ -359,33 +563,77 @@ public abstract class Assert {
 		isAssignable(superType, subType, "");
 	}
 
+	/**
+	 * Assert that {@code superType.isAssignableFrom(subType)} is {@code true}.
+	 * <pre class="code">
+	 * Assert.isAssignable(Number.class, myClass, () -&gt; "Processing " + myClass.getSimpleName() + ":");
+	 * </pre>
+	 * @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<String> 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}.
 	 * <pre class="code">Assert.isAssignable(Number.class, myClass);</pre>
 	 * @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}.
+	 * <p>Call {@link #isTrue} if you wish to throw an {@code IllegalArgumentException}
+	 * on an assertion failure.
+	 * <pre class="code">
+	 * Assert.state(id == null,
+	 *     () -&gt; "ID for " + entity.getName() + " must not already be initialized");
+	 * </pre>
+	 * @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<String> messageSupplier) {
+		if (!expression) {
+			throw new IllegalStateException(nullSafeGet(messageSupplier));
+		}
+	}
+
+	/**
+	 * Assert a boolean expression, throwing an {@code IllegalStateException}
+	 * if the expression evaluates to {@code false}.
+	 * <p>Call {@link #isTrue} if you wish to throw an {@code IllegalArgumentException}
+	 * on an assertion failure.
 	 * <pre class="code">Assert.state(id == null, "The id property must not already be initialized");</pre>
 	 * @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}.
-	 * <p>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}.
+	 * <p>Call {@link #isTrue} if you wish to throw an {@code IllegalArgumentException}
+	 * on an assertion failure.
 	 * <pre class="code">Assert.state(id == null);</pre>
 	 * @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<String> messageSupplier) {
+		return (messageSupplier != null ? messageSupplier.get() : null);
+	}
+
 }

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<String>) 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<String>) 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<String>) 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<String>) 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<String>) 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<String>) 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<String>) 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<String>) 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<String>) null);
 	}
 
 	@Test
-	public void assertNotEmptyWithCollectionSunnyDay() throws Exception {
-		List<String> 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<String>) null);
+	}
+
+	@Test
+	public void isInstanceOf() {
+		Assert.isInstanceOf(String.class, "foo");
 	}
 
 	@Test
-	public void assertNotEmptyWithMapSunnyDay() throws Exception {
-		Map<String, String> 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<String>) 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<String>) 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<String>) null);
+	}
+
 }