public static  void doesNotContain(String textToSearch,
    String substring) 
{
		doesNotContain(textToSearch, substring,
				"[Assertion failed] - this String argument must not contain the substring [" + substring + "]");
}

Assert that the given text does not contain the given substring.

Assert.doesNotContain(name, "rod");

 public static  void doesNotContain(String textToSearch,
    String substring,
    String message) 
{
		if (StringUtils.hasLength(textToSearch) && StringUtils.hasLength(substring) &&
				textToSearch.indexOf(substring) != -1) {
			throw new IllegalArgumentException(message);
		}
}

Assert that the given text does not contain the given substring.

Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");

 public static  void hasLength(String text) 
{
		hasLength(text,
				"[Assertion failed] - this String argument must have length; it must not be null or empty");
}

Assert that the given String is not empty; that is, it must not be null and not the empty String.

Assert.hasLength(name);

 public static  void hasLength(String text,
    String message) 
{
		if (!StringUtils.hasLength(text)) {
			throw new IllegalArgumentException(message);
		}
}

Assert that the given String is not empty; that is, it must not be null and not the empty String.

Assert.hasLength(name, "Name must not be empty");

 public static  void hasText(String text) 
{
		hasText(text,
				"[Assertion failed] - this String argument must have text; it must not be null, empty, or blank");
}

Assert that the given String has valid text content; that is, it must not be null and must contain at least one non-whitespace character.

Assert.hasText(name, "'name' must not be empty");

 public static  void hasText(String text,
    String message) 
{
		if (!StringUtils.hasText(text)) {
			throw new IllegalArgumentException(message);
		}
}

Assert that the given String has valid text content; that is, it must not be null and must contain at least one non-whitespace character.

Assert.hasText(name, "'name' must not be empty");

 public static  void isAssignable(Class superType,
    Class subType) 
{
		isAssignable(superType, subType, "");
}

Assert that superType.isAssignableFrom(subType) is true.

Assert.isAssignable(Number.class, myClass);

 public static  void isAssignable(Class superType,
    Class subType,
    String message) 
{
		notNull(superType, "Type to check against must not be null");
		if (subType == null || !superType.isAssignableFrom(subType)) {
			throw new IllegalArgumentException(message + subType + " is not assignable to " + superType);
		}
}

Assert that superType.isAssignableFrom(subType) is true.

Assert.isAssignable(Number.class, myClass);

 public static  void isInstanceOf(Class clazz,
    Object obj) 
{
		isInstanceOf(clazz, obj, "");
}

Assert that the provided object is an instance of the provided class.

Assert.instanceOf(Foo.class, foo);

 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(message +
					"Object of class [" + (obj != null ? obj.getClass().getName() : "null") +
					"] must be an instance of " + type);
		}
}

Assert that the provided object is an instance of the provided class.

Assert.instanceOf(Foo.class, foo);

 public static  void isNull(Object object) 
{
		isNull(object, "[Assertion failed] - the object argument must be null");
}

Assert that an object is null .

Assert.isNull(value);

 public static  void isNull(Object object,
    String message) 
{
		if (object != null) {
			throw new IllegalArgumentException(message);
		}
}

Assert that an object is null .

Assert.isNull(value, "The value must be null");

 public static  void isTrue(boolean expression) 
{
		isTrue(expression, "[Assertion failed] - this expression must be true");
}

Assert a boolean expression, throwing IllegalArgumentException if the test result is false.

Assert.isTrue(i > 0);

 public static  void isTrue(boolean expression,
    String message) 
{
		if (!expression) {
			throw new IllegalArgumentException(message);
		}
}

Assert a boolean expression, throwing IllegalArgumentException if the test result is false.

Assert.isTrue(i > 0, "The value must be greater than zero");

 public static  void noNullElements(Object[] array) 
{
		noNullElements(array, "[Assertion failed] - this array must not contain any null elements");
}

Assert that an array has no null elements. Note: Does not complain if the array is empty!

Assert.noNullElements(array);

 public static  void noNullElements(Object[] array,
    String message) 
{
		if (array != null) {
			for (int i = 0; i <  array.length; i++) {
				if (array[i] == null) {
					throw new IllegalArgumentException(message);
				}
			}
		}
}

Assert that an array has no null elements. Note: Does not complain if the array is empty!

Assert.noNullElements(array, "The array must have non-null elements");

 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 elements; that is, it must not be null and must have at least one element.

Assert.notEmpty(array);

 public static  void notEmpty(Collection collection) 
{
		notEmpty(collection,
				"[Assertion failed] - this collection must not be empty: it must contain at least 1 element");
}

Assert that a collection has elements; that is, it must not be null and must have at least one element.

Assert.notEmpty(collection, "Collection must have elements");

 public static  void notEmpty(Map map) 
{
		notEmpty(map, "[Assertion failed] - this map must not be empty; it must contain at least one entry");
}

Assert that a Map has entries; that is, it must not be null and must have at least one entry.

Assert.notEmpty(map);

 public static  void notEmpty(Object[] array,
    String message) 
{
		if (ObjectUtils.isEmpty(array)) {
			throw new IllegalArgumentException(message);
		}
}

Assert that an array has elements; that is, it must not be null and must have at least one element.

Assert.notEmpty(array, "The array must have elements");

 public static  void notEmpty(Collection collection,
    String message) 
{
		if (CollectionUtils.isEmpty(collection)) {
			throw new IllegalArgumentException(message);
		}
}

Assert that a collection has elements; that is, it must not be null and must have at least one element.

Assert.notEmpty(collection, "Collection must have elements");

 public static  void notEmpty(Map map,
    String message) 
{
		if (CollectionUtils.isEmpty(map)) {
			throw new IllegalArgumentException(message);
		}
}

Assert that a Map has entries; that is, it must not be null and must have at least one entry.

Assert.notEmpty(map, "Map must have entries");

 public static  void notNull(Object object) 
{
		notNull(object, "[Assertion failed] - this argument is required; it must not be null");
}

Assert that an object is not null .

Assert.notNull(clazz);

 public static  void notNull(Object object,
    String message) 
{
		if (object == null) {
			throw new IllegalArgumentException(message);
		}
}

Assert that an object is not null .

Assert.notNull(clazz, "The class must not be null");

 public static  void state(boolean expression) 
{
		state(expression, "[Assertion failed] - this state invariant must be true");
}

Assert a boolean expression, throwing IllegalStateException if the test result is false.

Call #isTrue(boolean) if you wish to throw IllegalArgumentException on an assertion failure.

Assert.state(id == null);

 public static  void state(boolean expression,
    String message) 
{
		if (!expression) {
			throw new IllegalStateException(message);
		}
}

Assert a boolean expression, throwing IllegalStateException if the test result is false. Call isTrue if you wish to throw IllegalArgumentException on an assertion failure.

Assert.state(id == null, "The id property must not already be initialized");