Assert (JJWT :: API 0.12.4 API)

java.lang.Object
- io.jsonwebtoken.lang.Assert

```
public final class Assert
extends Object
```
Utility methods for providing argument and state assertions to reduce repeating these patterns and otherwise increasing cyclomatic complexity.

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`doesNotContain(String textToSearch, String substring)` Assert that the given text does not contain the given substring.
`static void`	`doesNotContain(String textToSearch, String substring, String message)` Assert that the given text does not contain the given substring.
`static <T extends Comparable<T>> T`	`eq(T value, T requirement, String msg)` Asserts that a specified `value` is equal to the given `requirement`, throwing an `IllegalArgumentException` with the given message if not.
`static <T extends Comparable<T>> T`	`gt(T value, T requirement, String msg)` Asserts that a specified `value` is greater than the given `requirement`, throwing an `IllegalArgumentException` with the given message if not.
`static void`	`hasLength(String text)` Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
`static void`	`hasLength(String text, String message)` Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
`static void`	`hasText(String text)` 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.
`static <T extends CharSequence> T`	`hasText(T text, String 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.
`static void`	`isAssignable(Class superType, Class subType)` Assert that `superType.isAssignableFrom(subType)` is `true`.
`static void`	`isAssignable(Class superType, Class subType, String message)` Assert that `superType.isAssignableFrom(subType)` is `true`.
`static <T> T`	`isInstanceOf(Class<T> clazz, Object obj)` Assert that the provided object is an instance of the provided class.
`static <T> T`	`isInstanceOf(Class<T> type, Object obj, String message)` Assert that the provided object is an instance of the provided class.
`static void`	`isNull(Object object)` Assert that an object is `null` .
`static void`	`isNull(Object object, String message)` Assert that an object is `null` .
`static void`	`isTrue(boolean expression)` Assert a boolean expression, throwing `IllegalArgumentException` if the test result is `false`.
`static void`	`isTrue(boolean expression, String message)` Assert a boolean expression, throwing `IllegalArgumentException` if the test result is `false`.
`static <T extends Comparable<T>> T`	`lte(T value, T requirement, String msg)` Asserts that a specified `value` is less than or equal to the given `requirement`, throwing an `IllegalArgumentException` with the given message if not.
`static void`	`noNullElements(Object[] array)` Assert that an array has no null elements.
`static void`	`noNullElements(Object[] array, String message)` Assert that an array has no null elements.
`static byte[]`	`notEmpty(byte[] array, String msg)` Assert that the specified byte array is not null and has at least one byte element.
`static char[]`	`notEmpty(char[] chars, String msg)` Assert that the specified character array is not null and has at least one byte element.
`static void`	`notEmpty(Collection<?> collection)` Assert that a collection has elements; that is, it must not be `null` and must have at least one element.
`static void`	`notEmpty(Map map)` Assert that a Map has entries; that is, it must not be `null` and must have at least one entry.
`static void`	`notEmpty(Object[] array)` Assert that an array has elements; that is, it must not be `null` and must have at least one element.
`static Object[]`	`notEmpty(Object[] array, String message)` Assert that an array has elements; that is, it must not be `null` and must have at least one element.
`static <T extends Collection<?>> T`	`notEmpty(T collection, String message)` Assert that a collection has elements; that is, it must not be `null` and must have at least one element.
`static <T extends Map<?,?>> T`	`notEmpty(T map, String message)` Assert that a Map has entries; that is, it must not be `null` and must have at least one entry.
`static void`	`notNull(Object object)` Assert that an object is not `null` .
`static <T> T`	`notNull(T object, String message)` Assert that an object is not `null` .
`static void`	`state(boolean expression)` Assert a boolean expression, throwing `IllegalStateException` if the test result is `false`.
`static void`	`state(boolean expression, String message)` Assert a boolean expression, throwing `IllegalStateException` if the test result is `false`.
`static <T> T`	`stateIsInstance(Class<T> type, Object obj, String message)` Asserts that the provided object is an instance of the provided class, throwing an `IllegalStateException` otherwise.
`static <T> T`	`stateNotNull(T value, String msg)` Asserts that the specified `value` is not null, otherwise throws an `IllegalStateException` with the specified `msg`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - isTrue
```
public static void isTrue(boolean expression,
          String message)
```
    Assert a boolean expression, throwing IllegalArgumentException if the test result is false.
```
Assert.isTrue(i > 0, "The value must be greater than zero");
```
    Parameters:
    expression - a boolean expression
    message - the exception message to use if the assertion fails
    
    Throws:
    
    IllegalArgumentException - if expression is false
  - isTrue
```
public static void isTrue(boolean expression)
```
    Assert a boolean expression, throwing IllegalArgumentException if the test result is false.
```
Assert.isTrue(i > 0);
```
    Parameters:
    expression - a boolean expression
    
    Throws:
    
    IllegalArgumentException - if expression is false
  - isNull
```
public static void isNull(Object object,
          String message)
```
    Assert that an object is null .
```
Assert.isNull(value, "The value must be null");
```
    Parameters:
    object - the object to check
    message - the exception message to use if the assertion fails
    
    Throws:
    
    IllegalArgumentException - if the object is not null
  - isNull
```
public static void isNull(Object object)
```
    Assert that an object is null .
```
Assert.isNull(value);
```
    Parameters:
    object - the object to check
    
    Throws:
    
    IllegalArgumentException - if the object is not null
  - notNull
```
public static <T> T notNull(T object,
            String message)
```
    Assert that an object is not null .
```
Assert.notNull(clazz, "The class must not be null");
```
    Type Parameters:
    T - the type of object
    Parameters:
    object - the object to check
    message - the exception message to use if the assertion fails
    
    Returns:
    the non-null object
    
    Throws:
    
    IllegalArgumentException - if the object is null
  - notNull
```
public static void notNull(Object object)
```
    Assert that an object is not null .
```
Assert.notNull(clazz);
```
    Parameters:
    object - the object to check
    
    Throws:
    
    IllegalArgumentException - if the object is null
  - hasLength
```
public static void hasLength(String text,
             String 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");
```
    Parameters:
    text - the String to check
    message - the exception message to use if the assertion fails
    See Also:
    Strings.hasLength(java.lang.CharSequence)
  - hasLength
```
public static void hasLength(String text)
```
    Assert that the given String is not empty; that is, it must not be null and not the empty String.
```
Assert.hasLength(name);
```
    Parameters:
    text - the String to check
    See Also:
    Strings.hasLength(java.lang.CharSequence)
  - hasText
```
public static <T extends CharSequence> T hasText(T text,
                                 String 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");
```
    Type Parameters:
    T - the type of CharSequence
    Parameters:
    text - the CharSequence to check
    message - the exception message to use if the assertion fails
    
    Returns:
    the CharSequence if it has text
    See Also:
    Strings.hasText(java.lang.CharSequence)
  - hasText
```
public static void hasText(String text)
```
    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");
```
    Parameters:
    text - the String to check
    See Also:
    Strings.hasText(java.lang.CharSequence)
  - doesNotContain
```
public static void doesNotContain(String textToSearch,
                  String substring,
                  String message)
```
    Assert that the given text does not contain the given substring.
```
Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
```
    Parameters:
    textToSearch - the text to search
    substring - the substring to find within the text
    message - the exception message to use if the assertion fails
  - doesNotContain
```
public static void doesNotContain(String textToSearch,
                  String substring)
```
    Assert that the given text does not contain the given substring.
```
Assert.doesNotContain(name, "rod");
```
    Parameters:
    textToSearch - the text to search
    substring - the substring to find within the text
  - notEmpty
```
public static Object[] notEmpty(Object[] array,
                String 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");
```
    Parameters:
    array - the array to check
    message - the exception message to use if the assertion fails
    
    Returns:
    the non-empty array for immediate use
    
    Throws:
    
    IllegalArgumentException - if the object array is null or has no elements
  - notEmpty
```
public static void notEmpty(Object[] array)
```
    Assert that an array has elements; that is, it must not be null and must have at least one element.
```
Assert.notEmpty(array);
```
    Parameters:
    array - the array to check
    
    Throws:
    
    IllegalArgumentException - if the object array is null or has no elements
  - notEmpty
```
public static byte[] notEmpty(byte[] array,
              String msg)
```
    Assert that the specified byte array is not null and has at least one byte element.
    
    Parameters:
    array - the byte array to check
    msg - the exception message to use if the assertion fails
    
    Returns:
    the byte array if the assertion passes
    
    Throws:
    
    IllegalArgumentException - if the byte array is null or empty
    Since:
    
    0.12.0
  - notEmpty
```
public static char[] notEmpty(char[] chars,
              String msg)
```
    Assert that the specified character array is not null and has at least one byte element.
    
    Parameters:
    chars - the character array to check
    msg - the exception message to use if the assertion fails
    
    Returns:
    the character array if the assertion passes
    
    Throws:
    
    IllegalArgumentException - if the character array is null or empty
    Since:
    
    0.12.0
  - noNullElements
```
public static void noNullElements(Object[] array,
                  String 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");
```
    Parameters:
    array - the array to check
    message - the exception message to use if the assertion fails
    
    Throws:
    
    IllegalArgumentException - if the object array contains a null element
  - noNullElements
```
public static void noNullElements(Object[] array)
```
    Assert that an array has no null elements. Note: Does not complain if the array is empty!
```
Assert.noNullElements(array);
```
    Parameters:
    array - the array to check
    
    Throws:
    
    IllegalArgumentException - if the object array contains a null element
  - notEmpty
```
public static <T extends Collection<?>> T notEmpty(T collection,
                                   String 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");
```
    Type Parameters:
    T - the type of collection
    Parameters:
    collection - the collection to check
    message - the exception message to use if the assertion fails
    
    Returns:
    the non-null, non-empty collection
    
    Throws:
    
    IllegalArgumentException - if the collection is null or has no elements
  - notEmpty
```
public static void notEmpty(Collection<?> collection)
```
    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");
```
    Parameters:
    collection - the collection to check
    
    Throws:
    
    IllegalArgumentException - if the collection is null or has no elements
  - notEmpty
```
public static <T extends Map<?,?>> T notEmpty(T map,
                              String 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");
```
    Type Parameters:
    T - the type of Map to check
    Parameters:
    map - the map to check
    message - the exception message to use if the assertion fails
    
    Returns:
    the non-null, non-empty map
    
    Throws:
    
    IllegalArgumentException - if the map is null or has no entries
  - notEmpty
```
public static void notEmpty(Map map)
```
    Assert that a Map has entries; that is, it must not be null and must have at least one entry.
```
Assert.notEmpty(map);
```
    Parameters:
    map - the map to check
    
    Throws:
    
    IllegalArgumentException - if the map is null or has no entries
  - isInstanceOf
```
public static <T> T isInstanceOf(Class<T> clazz,
                 Object obj)
```
    Assert that the provided object is an instance of the provided class.
```
Assert.instanceOf(Foo.class, foo);
```
    Type Parameters:
    T - the type of instance expected
    Parameters:
    clazz - the required class
    obj - the object to check
    
    Returns:
    the expected instance of type T
    
    Throws:
    
    IllegalArgumentException - if the object is not an instance of clazz
    See Also:
    Class.isInstance(java.lang.Object)
  - isInstanceOf
```
public static <T> T isInstanceOf(Class<T> type,
                 Object obj,
                 String message)
```
    Assert that the provided object is an instance of the provided class.
```
Assert.instanceOf(Foo.class, foo);
```
    Type Parameters:
    T - the object's expected type
    Parameters:
    type - the type to check against
    obj - the object to check
    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 a ": " or ". " so that the function generate message looks ok when prepended to it.
    
    Returns:
    the non-null object IFF it is an instance of the specified type.
    
    Throws:
    
    IllegalArgumentException - if the object is not an instance of clazz
    See Also:
    Class.isInstance(java.lang.Object)
  - stateIsInstance
```
public static <T> T stateIsInstance(Class<T> type,
                    Object obj,
                    String message)
```
    Asserts that the provided object is an instance of the provided class, throwing an IllegalStateException otherwise.
```
Assert.stateIsInstance(Foo.class, foo);
```
    Type Parameters:
    T - the object's expected type
    Parameters:
    type - the type to check against
    obj - the object to check
    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 a ": " or ". " so that the function generate message looks ok when prepended to it.
    
    Returns:
    the non-null object IFF it is an instance of the specified type.
    
    Throws:
    
    IllegalStateException - if the object is not an instance of clazz
    See Also:
    Class.isInstance(java.lang.Object)
  - isAssignable
```
public static void isAssignable(Class superType,
                Class subType)
```
    Assert that superType.isAssignableFrom(subType) is true.
```
Assert.isAssignable(Number.class, myClass);
```
    Parameters:
    superType - the super type to check
    subType - the sub type to check
    
    Throws:
    
    IllegalArgumentException - if the classes are not assignable
  - isAssignable
```
public static void isAssignable(Class superType,
                Class subType,
                String message)
```
    Assert that superType.isAssignableFrom(subType) is true.
```
Assert.isAssignable(Number.class, myClass);
```
    Parameters:
    superType - the super type to check against
    subType - the sub type to check
    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 a ": " or ". " so that the function generate message looks ok when prepended to it.
    
    Throws:
    
    IllegalArgumentException - if the classes are not assignable
  - eq
```
public static <T extends Comparable<T>> T eq(T value,
                             T requirement,
                             String msg)
```
    Asserts that a specified value is equal to the given requirement, throwing an IllegalArgumentException with the given message if not.
    
    Type Parameters:
    T - the type of argument
    Parameters:
    value - the value to check
    requirement - the requirement that value must be greater than
    msg - the message to use for the IllegalArgumentException if thrown.
    
    Returns:
    value if greater than the specified requirement.
    Since:
    
    0.12.0
  - gt
```
public static <T extends Comparable<T>> T gt(T value,
                             T requirement,
                             String msg)
```
    Asserts that a specified value is greater than the given requirement, throwing an IllegalArgumentException with the given message if not.
    
    Type Parameters:
    T - the type of value to check and return if the requirement is met
    Parameters:
    value - the value to check
    requirement - the requirement that value must be greater than
    msg - the message to use for the IllegalArgumentException if thrown.
    
    Returns:
    value if greater than the specified requirement.
    Since:
    
    0.12.0
  - lte
```
public static <T extends Comparable<T>> T lte(T value,
                              T requirement,
                              String msg)
```
    Asserts that a specified value is less than or equal to the given requirement, throwing an IllegalArgumentException with the given message if not.
    
    Type Parameters:
    T - the type of value to check and return if the requirement is met
    Parameters:
    value - the value to check
    requirement - the requirement that value must be greater than
    msg - the message to use for the IllegalArgumentException if thrown.
    
    Returns:
    value if greater than the specified requirement.
    Since:
    
    0.12.0
  - state
```
public static void state(boolean expression,
         String 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");
```
    Parameters:
    expression - a boolean expression
    message - the exception message to use if the assertion fails
    
    Throws:
    
    IllegalStateException - if expression is false
  - state
```
public static void state(boolean expression)
```
    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);
```
    Parameters:
    expression - a boolean expression
    
    Throws:
    
    IllegalStateException - if the supplied expression is false
  - stateNotNull
```
public static <T> T stateNotNull(T value,
                 String msg)
                      throws IllegalStateException
```
    Asserts that the specified value is not null, otherwise throws an IllegalStateException with the specified msg. Intended to be used with code invariants (as opposed to method arguments, like notNull(Object)).
    
    Type Parameters:
    T - value type
    Parameters:
    value - value to assert is not null
    msg - exception message to use if value is null
    
    Returns:
    the non-null value
    
    Throws:
    
    IllegalStateException - with the specified msg if value is null.
    Since:
    
    0.12.0

Class Assert

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isTrue

isTrue

isNull

isNull

notNull

notNull

hasLength

hasLength

hasText

hasText

doesNotContain

doesNotContain

notEmpty

notEmpty

notEmpty

notEmpty

noNullElements

noNullElements

notEmpty

notEmpty

notEmpty

notEmpty

isInstanceOf

isInstanceOf

stateIsInstance

isAssignable

isAssignable

eq

gt

lte

state

state

stateNotNull