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}.
+	 * <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);
+	}
+
 }
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<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);
+	}
+
 }