root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity

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
This commit is contained in:
Sam Brannen 2016-07-12 16:36:30 +02:00
parent 3d4338f555
commit 17dd5dd22d
2 changed files with 850 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

390
spring-core/src/main/java/org/springframework/util/Assert.java
View File

@ -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 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, () -&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 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,36 +497,60 @@ 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 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 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 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)) {
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}.
@ -361,31 +565,75 @@ public abstract class Assert {
/**
* Assert that {@code superType.isAssignableFrom(subType)} is {@code true}.
* <pre class="code">Assert.isAssignable(Number.class, myClass);</pre>
* <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 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 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, String message) {
notNull(superType, "Type to check against must not be null");
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)) {
throw new IllegalArgumentException((StringUtils.hasLength(message) ? message + " " : "") +
subType + " is not assignable to " + superType);
isAssignableCheckFailed(superType, subType, nullSafeGet(messageSupplier));
}
}
/**
* 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 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 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, "Super type to check against must not be null");
if (subType == null || !superType.isAssignableFrom(subType)) {
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 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);
}
}

614
spring-core/src/test/java/org/springframework/util/AssertTests.java
View File

@ -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<>());
}
@Test(expected = IllegalArgumentException.class)
public void instanceOfWithTypeMismatch() {
Assert.isInstanceOf(HashMap.class, new HashSet<>());
public void isTrue() {
Assert.isTrue(true);
}
@Test
public void instanceOfNoMessage() throws Exception {
public void isTrueWithFalseExpression() {
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);
}
@Test
public void instanceOfMessage() throws Exception {
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.");
}
@Test
public void isNullDoesNotThrowExceptionIfArgumentIsNullWithMessage() {
Assert.isNull(null, "Bla");
}
@Test
public void isNullDoesNotThrowExceptionIfArgumentIsNull() {
Assert.isNull(null);
}
@Test(expected = IllegalArgumentException.class)
public void isNullThrowsExceptionIfArgumentIsNotNull() {
Assert.isNull(new Object());
}
@Test(expected = IllegalArgumentException.class)
public void isTrueWithFalseExpressionThrowsException() throws Exception {
Assert.isTrue(false);
}
@Test
public void isTrueWithTrueExpressionSunnyDay() throws Exception {
Assert.isTrue(true);
}
@Test(expected = IllegalArgumentException.class)
public void testHasLengthWithNullStringThrowsException() throws Exception {
Assert.hasLength(null);
}
@Test(expected = IllegalArgumentException.class)
public void hasLengthWithEmptyStringThrowsException() throws Exception {
Assert.hasLength("");
public void isTrueWithMessageSupplier() {
Assert.isTrue(true, () -> "enigma");
}
@Test
public void hasLengthWithWhitespaceOnlyStringDoesNotThrowException() throws Exception {
Assert.hasLength("\t ");
public void isTrueWithFalseAndMessageSupplier() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("enigma");
Assert.isTrue(false, () -> "enigma");
}
@Test
public void hasLengthSunnyDay() throws Exception {
public void isTrueWithFalseAndNullMessageSupplier() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage(equalTo(null));
Assert.isTrue(false, (Supplier<String>) null);
}
@Test
public void isNull() {
Assert.isNull(null);
}
@Test
public void isNullWithMessage() {
Assert.isNull(null, "Bla");
}
@Test
public void isNullWithNonNullObject() {
thrown.expect(IllegalArgumentException.class);
Assert.isNull(new Object());
}
@Test
public void isNullWithMessageSupplier() {
Assert.isNull(null, () -> "enigma");
}
@Test
public void isNullWithNonNullObjectAndMessageSupplier() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("enigma");
Assert.isNull("foo", () -> "enigma");
}
@Test
public void isNullWithNonNullObjectAndNullMessageSupplier() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage(equalTo(null));
Assert.isNull("foo", (Supplier<String>) null);
}
@Test
public void notNull() {
Assert.notNull("foo");
}
@Test
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 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 doesNotContainWithEmptySubstringDoesNotThrowException() throws Exception {
Assert.doesNotContain("A cool chick's name is Brod. ", "");
public void doesNotContainWithEmptySubstring() {
Assert.doesNotContain("A cool chick's name is Brod.", "");
}
@Test(expected = IllegalArgumentException.class)
public void assertNotEmptyWithNullCollectionThrowsException() throws Exception {
@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 notEmptyCollection() {
Assert.notEmpty(singletonList("foo"));
}
@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 assertNotEmptyWithCollectionSunnyDay() throws Exception {
List<String> collection = new ArrayList<>();
collection.add("");
Assert.notEmpty(collection);
public void notEmptyCollectionWithEmptyCollectionAndMessageSupplier() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("enigma");
Assert.notEmpty(emptyList(), () -> "enigma");
}
@Test(expected = IllegalArgumentException.class)
public void assertNotEmptyWithNullMapThrowsException() throws Exception {
@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 notEmptyMap() {
Assert.notEmpty(singletonMap("foo", "bar"));
}
@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 assertNotEmptyWithMapSunnyDay() throws Exception {
Map<String, String> map = new HashMap<>();
map.put("", "");
Assert.notEmpty(map);
public void notEmptyMapWithMessageSupplier() {
Assert.notEmpty(singletonMap("foo", "bar"), () -> "enigma");
}
@Test(expected = IllegalArgumentException.class)
public void isInstanceofClassWithNullInstanceThrowsException() throws Exception {
@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 isInstanceOfWithNullType() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Type to check against must not be null");
Assert.isInstanceOf(null, "foo");
}
@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 {
@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 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 stateWithTrueExpressionSunnyDay() throws Exception {
Assert.state(true);
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);
}
}