java.lang.Object
- com.helger.commons.ValueEnforcer

```
@Immutable
public final class ValueEnforcer
extends Object
```
This class contains "runtime assertions" utility methods. It works like Objects.requireNonNull(Object) but offers many more possibilities.

Author:

Philip Helger

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static void`	`isArrayOfsLen(boolean[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(byte[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(char[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(double[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(float[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(int[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(long[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(short[] aArray, int nOfs, int nLen)`
`static void`	`isArrayOfsLen(Object[] aArray, int nOfs, int nLen)`
`static double`	`isBetweenExclusive(double dValue, String sName, double dLowerBoundExclusive, double dUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static double`	`isBetweenExclusive(double dValue, Supplier<? extends String> aName, double dLowerBoundExclusive, double dUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static float`	`isBetweenExclusive(float fValue, String sName, float fLowerBoundExclusive, float fUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static float`	`isBetweenExclusive(float fValue, Supplier<? extends String> aName, float fLowerBoundExclusive, float fUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static int`	`isBetweenExclusive(int nValue, String sName, int nLowerBoundExclusive, int nUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static int`	`isBetweenExclusive(int nValue, Supplier<? extends String> aName, int nLowerBoundExclusive, int nUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static long`	`isBetweenExclusive(long nValue, String sName, long nLowerBoundExclusive, long nUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static long`	`isBetweenExclusive(long nValue, Supplier<? extends String> aName, long nLowerBoundExclusive, long nUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static short`	`isBetweenExclusive(short nValue, String sName, short nLowerBoundExclusive, short nUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static short`	`isBetweenExclusive(short nValue, Supplier<? extends String> aName, short nLowerBoundExclusive, short nUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static BigDecimal`	`isBetweenExclusive(BigDecimal aValue, String sName, BigDecimal aLowerBoundExclusive, BigDecimal aUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static BigDecimal`	`isBetweenExclusive(BigDecimal aValue, Supplier<? extends String> aName, BigDecimal aLowerBoundExclusive, BigDecimal aUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static BigInteger`	`isBetweenExclusive(BigInteger aValue, String sName, BigInteger aLowerBoundExclusive, BigInteger aUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static BigInteger`	`isBetweenExclusive(BigInteger aValue, Supplier<? extends String> aName, BigInteger aLowerBoundExclusive, BigInteger aUpperBoundExclusive)`	Check if `nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive`
`static double`	`isBetweenInclusive(double dValue, String sName, double dLowerBoundInclusive, double dUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static double`	`isBetweenInclusive(double dValue, Supplier<? extends String> aName, double dLowerBoundInclusive, double dUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static float`	`isBetweenInclusive(float fValue, String sName, float fLowerBoundInclusive, float fUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static float`	`isBetweenInclusive(float fValue, Supplier<? extends String> aName, float fLowerBoundInclusive, float fUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static int`	`isBetweenInclusive(int nValue, String sName, int nLowerBoundInclusive, int nUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static int`	`isBetweenInclusive(int nValue, Supplier<? extends String> aName, int nLowerBoundInclusive, int nUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static long`	`isBetweenInclusive(long nValue, String sName, long nLowerBoundInclusive, long nUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static long`	`isBetweenInclusive(long nValue, Supplier<? extends String> aName, long nLowerBoundInclusive, long nUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static short`	`isBetweenInclusive(short nValue, String sName, short nLowerBoundInclusive, short nUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static short`	`isBetweenInclusive(short nValue, Supplier<? extends String> aName, short nLowerBoundInclusive, short nUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static BigDecimal`	`isBetweenInclusive(BigDecimal aValue, String sName, BigDecimal aLowerBoundInclusive, BigDecimal aUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static BigDecimal`	`isBetweenInclusive(BigDecimal aValue, Supplier<? extends String> aName, BigDecimal aLowerBoundInclusive, BigDecimal aUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static BigInteger`	`isBetweenInclusive(BigInteger aValue, String sName, BigInteger aLowerBoundInclusive, BigInteger aUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static BigInteger`	`isBetweenInclusive(BigInteger aValue, Supplier<? extends String> aName, BigInteger aLowerBoundInclusive, BigInteger aUpperBoundInclusive)`	Check if `nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive`
`static boolean`	`isEnabled()`
`static void`	`isEqual(double dValue, double dExpectedValue, String sName)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static void`	`isEqual(double dValue, double dExpectedValue, Supplier<? extends String> aName)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static void`	`isEqual(int nValue, int nExpectedValue, String sName)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static void`	`isEqual(int nValue, int nExpectedValue, Supplier<? extends String> aName)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static void`	`isEqual(long nValue, long nExpectedValue, String sName)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static void`	`isEqual(long nValue, long nExpectedValue, Supplier<? extends String> aName)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static <T> T`	`isEqual(T aValue, T aExpectedValue, String sName)`	Check that the passed value is the same as the provided expected value using `equals` to check comparison.
`static <T> T`	`isEqual(T aValue, T aExpectedValue, Supplier<? extends String> aName)`	Check that the passed value is the same as the provided expected value using `equals` to check comparison.
`static void`	`isFalse(boolean bValue, String sMsg)`	Check that the passed value is `false`.
`static void`	`isFalse(boolean bValue, Supplier<? extends String> aMsg)`	Check that the passed value is `false`.
`static void`	`isFalse(BooleanSupplier aValue, String sMsg)`	Check that the passed value is `false`.
`static void`	`isFalse(BooleanSupplier aValue, Supplier<? extends String> aMsg)`	Check that the passed value is `false`.
`static double`	`isGE0(double dValue, String sName)`
`static double`	`isGE0(double dValue, Supplier<? extends String> aName)`
`static float`	`isGE0(float fValue, String sName)`
`static float`	`isGE0(float fValue, Supplier<? extends String> aName)`
`static int`	`isGE0(int nValue, String sName)`
`static int`	`isGE0(int nValue, Supplier<? extends String> aName)`
`static long`	`isGE0(long nValue, String sName)`
`static long`	`isGE0(long nValue, Supplier<? extends String> aName)`
`static short`	`isGE0(short nValue, String sName)`
`static short`	`isGE0(short nValue, Supplier<? extends String> aName)`
`static BigDecimal`	`isGE0(BigDecimal aValue, String sName)`
`static BigDecimal`	`isGE0(BigDecimal aValue, Supplier<? extends String> aName)`
`static BigInteger`	`isGE0(BigInteger aValue, String sName)`
`static BigInteger`	`isGE0(BigInteger aValue, Supplier<? extends String> aName)`
`static double`	`isGT0(double dValue, String sName)`
`static double`	`isGT0(double dValue, Supplier<? extends String> aName)`
`static float`	`isGT0(float fValue, String sName)`
`static float`	`isGT0(float fValue, Supplier<? extends String> aName)`
`static int`	`isGT0(int nValue, String sName)`
`static int`	`isGT0(int nValue, Supplier<? extends String> aName)`
`static long`	`isGT0(long nValue, String sName)`
`static long`	`isGT0(long nValue, Supplier<? extends String> aName)`
`static short`	`isGT0(short nValue, String sName)`
`static short`	`isGT0(short nValue, Supplier<? extends String> aName)`
`static BigDecimal`	`isGT0(BigDecimal aValue, String sName)`
`static BigDecimal`	`isGT0(BigDecimal aValue, Supplier<? extends String> aName)`
`static BigInteger`	`isGT0(BigInteger aValue, String sName)`
`static BigInteger`	`isGT0(BigInteger aValue, Supplier<? extends String> aName)`
`static <T> void`	`isInstanceOf(T aValue, Class<? extends T> aClass, String sMsg)`	Check that the passed value is an instance of the passed class.
`static <T> void`	`isInstanceOf(T aValue, Class<? extends T> aClass, Supplier<? extends String> aMsg)`	Check that the passed value is an instance of the passed class.
`static double`	`isLE0(double dValue, String sName)`
`static double`	`isLE0(double dValue, Supplier<? extends String> aName)`
`static float`	`isLE0(float fValue, String sName)`
`static float`	`isLE0(float fValue, Supplier<? extends String> aName)`
`static int`	`isLE0(int nValue, String sName)`
`static int`	`isLE0(int nValue, Supplier<? extends String> aName)`
`static long`	`isLE0(long nValue, String sName)`
`static long`	`isLE0(long nValue, Supplier<? extends String> aName)`
`static short`	`isLE0(short nValue, String sName)`
`static short`	`isLE0(short nValue, Supplier<? extends String> aName)`
`static BigDecimal`	`isLE0(BigDecimal aValue, String sName)`
`static BigDecimal`	`isLE0(BigDecimal aValue, Supplier<? extends String> aName)`
`static BigInteger`	`isLE0(BigInteger aValue, String sName)`
`static BigInteger`	`isLE0(BigInteger aValue, Supplier<? extends String> aName)`
`static double`	`isLT0(double dValue, String sName)`
`static double`	`isLT0(double dValue, Supplier<? extends String> aName)`
`static float`	`isLT0(float fValue, String sName)`
`static float`	`isLT0(float fValue, Supplier<? extends String> aName)`
`static int`	`isLT0(int nValue, String sName)`
`static int`	`isLT0(int nValue, Supplier<? extends String> aName)`
`static long`	`isLT0(long nValue, String sName)`
`static long`	`isLT0(long nValue, Supplier<? extends String> aName)`
`static short`	`isLT0(short nValue, String sName)`
`static short`	`isLT0(short nValue, Supplier<? extends String> aName)`
`static BigDecimal`	`isLT0(BigDecimal aValue, String sName)`
`static BigDecimal`	`isLT0(BigDecimal aValue, Supplier<? extends String> aName)`
`static BigInteger`	`isLT0(BigInteger aValue, String sName)`
`static BigInteger`	`isLT0(BigInteger aValue, Supplier<? extends String> aName)`
`static double`	`isNE0(double dValue, String sName)`
`static double`	`isNE0(double dValue, Supplier<? extends String> aName)`
`static int`	`isNE0(int nValue, String sName)`
`static int`	`isNE0(int nValue, Supplier<? extends String> aName)`
`static long`	`isNE0(long nValue, String sName)`
`static long`	`isNE0(long nValue, Supplier<? extends String> aName)`
`static BigDecimal`	`isNE0(BigDecimal aValue, String sName)`
`static BigDecimal`	`isNE0(BigDecimal aValue, Supplier<? extends String> aName)`
`static BigInteger`	`isNE0(BigInteger aValue, String sName)`
`static BigInteger`	`isNE0(BigInteger aValue, Supplier<? extends String> aName)`
`static void`	`isNull(Object aValue, String sName)`	Check that the passed value is `null`.
`static void`	`isNull(Object aValue, Supplier<? extends String> aName)`	Check that the passed value is `null`.
`static <T> T`	`isSame(T aValue, String sName, T aExpectedValue)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static <T> T`	`isSame(T aValue, Supplier<? extends String> aName, T aExpectedValue)`	Check that the passed value is the same as the provided expected value using `==` to check comparison.
`static void`	`isTrue(boolean bValue, String sMsg)`	Check that the passed value is `true`.
`static void`	`isTrue(boolean bValue, Supplier<? extends String> aMsg)`	Check that the passed value is `true`.
`static void`	`isTrue(BooleanSupplier aValue, String sMsg)`	Check that the passed value is `true`.
`static void`	`isTrue(BooleanSupplier aValue, Supplier<? extends String> aMsg)`	Check that the passed value is `true`.
`static <T> T[]`	`noNullValue(T[] aValue, String sName)`	Check that the passed Array contains no `null` value.
`static <T> T[]`	`noNullValue(T[] aValue, Supplier<? extends String> aName)`	Check that the passed Array contains no `null` value.
`static <T extends Iterable<?>> T`	`noNullValue(T aValue, String sName)`	Check that the passed iterable contains no `null` value.
`static <T extends Iterable<?>> T`	`noNullValue(T aValue, Supplier<? extends String> aName)`	Check that the passed iterable contains no `null` value.
`static boolean[]`	`notEmpty(boolean[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static boolean[]`	`notEmpty(boolean[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static byte[]`	`notEmpty(byte[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static byte[]`	`notEmpty(byte[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static char[]`	`notEmpty(char[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static char[]`	`notEmpty(char[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static double[]`	`notEmpty(double[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static double[]`	`notEmpty(double[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static float[]`	`notEmpty(float[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static float[]`	`notEmpty(float[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static int[]`	`notEmpty(int[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static int[]`	`notEmpty(int[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static long[]`	`notEmpty(long[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static long[]`	`notEmpty(long[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static short[]`	`notEmpty(short[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static short[]`	`notEmpty(short[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static <T> T[]`	`notEmpty(T[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty.
`static <T> T[]`	`notEmpty(T[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty.
`static <T extends CharSequence> T`	`notEmpty(T aValue, String sName)`	Check that the passed String is neither `null` nor empty.
`static <T extends CharSequence> T`	`notEmpty(T aValue, Supplier<? extends String> aName)`	Check that the passed String is neither `null` nor empty.
`static <T> T[]`	`notEmptyNoNullValue(T[] aValue, String sName)`	Check that the passed Array is neither `null` nor empty and that no `null` value is contained.
`static <T> T[]`	`notEmptyNoNullValue(T[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is neither `null` nor empty and that no `null` value is contained.
`static <T extends Iterable<?>> T`	`notEmptyNoNullValue(T aValue, String sName)`	Check that the passed collection is neither `null` nor empty and that no `null` value is contained.
`static <T extends Iterable<?>> T`	`notEmptyNoNullValue(T aValue, Supplier<? extends String> aName)`	Check that the passed collection is neither `null` nor empty and that no `null` value is contained.
`static <T> T`	`notNull(T aValue, String sName)`	Check that the passed value is not `null`.
`static <T> T`	`notNull(T aValue, Supplier<? extends String> aName)`	Check that the passed value is not `null`.
`static <T> T`	`notNullAndEquals(T aValue, String sName, T aExpectedValue)`	Check that the passed value is not `null` and equal to the provided expected value.
`static <T> T`	`notNullAndEquals(T aValue, Supplier<? extends String> aName, T aExpectedValue)`	Check that the passed value is not `null` and equal to the provided expected value.
`static <T> T[]`	`notNullNoNullValue(T[] aValue, String sName)`	Check that the passed Array is not `null` and that no `null` value is contained.
`static <T> T[]`	`notNullNoNullValue(T[] aValue, Supplier<? extends String> aName)`	Check that the passed Array is not `null` and that no `null` value is contained.
`static <T extends Iterable<?>> T`	`notNullNoNullValue(T aValue, String sName)`	Check that the passed collection is not `null` and that no `null` value is contained.
`static <T extends Iterable<?>> T`	`notNullNoNullValue(T aValue, Supplier<? extends String> aName)`	Check that the passed collection is not `null` and that no `null` value is contained.
`static <T> T`	`notNullNotEquals(T aValue, String sName, T aUnexpectedValue)`	Check that the passed value is not `null` and not equal to the provided value.
`static <T> T`	`notNullNotEquals(T aValue, Supplier<? extends String> aName, T aUnexpectedValue)`	Check that the passed value is not `null` and not equal to the provided value.
`static void`	`setEnabled(boolean bEnabled)`	Enable or disable the checks.

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

Method Detail

isEnabled
```
public static boolean isEnabled()
```
Returns:

true if the assertions are enabled, false otherwise. By default the checks are enabled.

setEnabled
```
public static void setEnabled(boolean bEnabled)
```
Enable or disable the checks. By default checks are enabled.

Parameters:

bEnabled - true to enable it, false otherwise.

isTrue
```
public static void isTrue(boolean bValue,
                          String sMsg)
```
Check that the passed value is true.

Parameters:

bValue - The value to check.

sMsg - The message to be emitted in case the value is false

Throws:

IllegalArgumentException - if the passed value is not null.

isTrue
```
public static void isTrue(boolean bValue,
                          @Nonnull
                          Supplier<? extends String> aMsg)
```
Check that the passed value is true.

Parameters:

bValue - The value to check.

aMsg - The message to be emitted in case the value is false

Throws:

IllegalArgumentException - if the passed value is not null.

isTrue
```
public static void isTrue(@Nonnull
                          BooleanSupplier aValue,
                          String sMsg)
```
Check that the passed value is true.

Parameters:

aValue - The value to check.

sMsg - The message to be emitted in case the value is false

Throws:

IllegalArgumentException - if the passed value is not null.

isTrue

public static void isTrue(@Nonnull
                          BooleanSupplier aValue,
                          @Nonnull
                          Supplier<? extends String> aMsg)

Check that the passed value is true.

Parameters:: aValue - The value to check.; aMsg - The message to be emitted in case the value is false
Throws:: IllegalArgumentException - if the passed value is not null.

isFalse
```
public static void isFalse(boolean bValue,
                           String sMsg)
```
Check that the passed value is false.

Parameters:

bValue - The value to check.

sMsg - The message to be emitted in case the value is true

Throws:

IllegalArgumentException - if the passed value is not null.

isFalse

public static void isFalse(boolean bValue,
                           @Nonnull
                           Supplier<? extends String> aMsg)

Check that the passed value is false.

Parameters:: bValue - The value to check.; aMsg - The message to be emitted in case the value is true
Throws:: IllegalArgumentException - if the passed value is not null.

isFalse
```
public static void isFalse(@Nonnull
                           BooleanSupplier aValue,
                           String sMsg)
```
Check that the passed value is false.

Parameters:

aValue - The value to check.

sMsg - The message to be emitted in case the value is true

Throws:

IllegalArgumentException - if the passed value is not null.

isFalse

public static void isFalse(@Nonnull
                           BooleanSupplier aValue,
                           @Nonnull
                           Supplier<? extends String> aMsg)

Check that the passed value is false.

Parameters:: aValue - The value to check.; aMsg - The message to be emitted in case the value is true
Throws:: IllegalArgumentException - if the passed value is not null.

isInstanceOf

public static <T> void isInstanceOf(@Nullable
                                    T aValue,
                                    @Nonnull
                                    Class<? extends T> aClass,
                                    String sMsg)

Check that the passed value is an instance of the passed class.

Type Parameters:: T - Type to check.
Parameters:: aValue - The value to check. May be null.; aClass - The class of which the passed value must be an instance. May not be null.; sMsg - The message to be emitted in case the value is false
Throws:: IllegalArgumentException - if the passed value is not null.

isInstanceOf

public static <T> void isInstanceOf(@Nullable
                                    T aValue,
                                    @Nonnull
                                    Class<? extends T> aClass,
                                    @Nonnull
                                    Supplier<? extends String> aMsg)

Check that the passed value is an instance of the passed class.

Type Parameters:: T - Type to check.
Parameters:: aValue - The value to check. May be null.; aClass - The class of which the passed value must be an instance. May not be null.; aMsg - The message to be emitted in case the value is false
Throws:: IllegalArgumentException - if the passed value is not null.

notNull
```
public static <T> T notNull(T aValue,
                            String sName)
```
Check that the passed value is not null.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

NullPointerException - if the passed value is null.

notNull
```
public static <T> T notNull(T aValue,
                            @Nonnull
                            Supplier<? extends String> aName)
```
Check that the passed value is not null.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

NullPointerException - if the passed value is null.

isNull
```
public static void isNull(Object aValue,
                          String sName)
```
Check that the passed value is null.

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

isNull

public static void isNull(Object aValue,
                          @Nonnull
                          Supplier<? extends String> aName)

Check that the passed value is null.

Parameters:: aValue - The value to check.; aName - The name of the value (e.g. the parameter name)
Throws:: IllegalArgumentException - if the passed value is not null.

notEmpty
```
public static <T extends CharSequence> T notEmpty(T aValue,
                                                  String sName)
```
Check that the passed String is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

public static <T extends CharSequence> T notEmpty(T aValue,
                                                  @Nonnull
                                                  Supplier<? extends String> aName)

Check that the passed String is neither null nor empty.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The String to check.; aName - The name of the value (e.g. the parameter name)
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is empty

notEmpty
```
public static <T> T[] notEmpty(T[] aValue,
                               String sName)
```
Check that the passed Array is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static <T> T[] notEmpty(T[] aValue,
                               @Nonnull
                               Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static boolean[] notEmpty(boolean[] aValue,
                                 String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static boolean[] notEmpty(boolean[] aValue,
                                 @Nonnull
                                 Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static byte[] notEmpty(byte[] aValue,
                              String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static byte[] notEmpty(byte[] aValue,
                              @Nonnull
                              Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static char[] notEmpty(char[] aValue,
                              String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static char[] notEmpty(char[] aValue,
                              @Nonnull
                              Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static double[] notEmpty(double[] aValue,
                                String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static double[] notEmpty(double[] aValue,
                                @Nonnull
                                Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static float[] notEmpty(float[] aValue,
                               String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static float[] notEmpty(float[] aValue,
                               @Nonnull
                               Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static int[] notEmpty(int[] aValue,
                             String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static int[] notEmpty(int[] aValue,
                             @Nonnull
                             Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static long[] notEmpty(long[] aValue,
                              String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static long[] notEmpty(long[] aValue,
                              @Nonnull
                              Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static short[] notEmpty(short[] aValue,
                               String sName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
public static short[] notEmpty(short[] aValue,
                               @Nonnull
                               Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty
```
@CodingStyleguideUnaware
public static <T extends Collection<?>> T notEmpty(T aValue,
                                                   String sName)
```
Check that the passed Collection is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@CodingStyleguideUnaware
public static <T extends Collection<?>> T notEmpty(T aValue,
                                                   @Nonnull
                                                   Supplier<? extends String> aName)

Check that the passed Collection is neither null nor empty.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The String to check.; aName - The name of the value (e.g. the parameter name)
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is empty

notEmpty
```
@CodingStyleguideUnaware
public static <T extends Iterable<?>> T notEmpty(T aValue,
                                                 String sName)
```
Check that the passed Iterable is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@CodingStyleguideUnaware
public static <T extends Iterable<?>> T notEmpty(T aValue,
                                                 @Nonnull
                                                 Supplier<? extends String> aName)

Check that the passed Iterable is neither null nor empty.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The String to check.; aName - The name of the value (e.g. the parameter name)
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is empty

notEmpty
```
@CodingStyleguideUnaware
public static <T extends Map<?,?>> T notEmpty(T aValue,
                                                    String sName)
```
Check that the passed Collection is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@CodingStyleguideUnaware
public static <T extends Map<?,?>> T notEmpty(T aValue,
                                                    @Nonnull
                                                    Supplier<? extends String> aName)

Check that the passed Collection is neither null nor empty.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The String to check.; aName - The name of the value (e.g. the parameter name)
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is empty

noNullValue
```
@Nullable
public static <T> T[] noNullValue(T[] aValue,
                                  String sName)
```
Check that the passed Array contains no null value. But the whole array can be null or empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check. May be null.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value. Maybe null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null value is contained

noNullValue
```
@Nullable
public static <T> T[] noNullValue(T[] aValue,
                                  @Nonnull
                                  Supplier<? extends String> aName)
```
Check that the passed Array contains no null value. But the whole array can be null or empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check. May be null.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value. Maybe null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null value is contained

noNullValue
```
@Nullable
public static <T extends Iterable<?>> T noNullValue(T aValue,
                                                    String sName)
```
Check that the passed iterable contains no null value. But the whole iterable can be null or empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The collection to check. May be null.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value. Maybe null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null value is contained

noNullValue
```
@Nullable
public static <T extends Iterable<?>> T noNullValue(T aValue,
                                                    @Nonnull
                                                    Supplier<? extends String> aName)
```
Check that the passed iterable contains no null value. But the whole iterable can be null or empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The collection to check. May be null.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value. Maybe null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null value is contained

noNullValue
```
@Nullable
@CodingStyleguideUnaware
public static <T extends Map<?,?>> T noNullValue(T aValue,
                                                       String sName)
```
Check that the passed map is neither null nor empty and that no null key or value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The map to check. May be null.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value. Maybe null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null key or null value is contained

noNullValue
```
@Nullable
@CodingStyleguideUnaware
public static <T extends Map<?,?>> T noNullValue(T aValue,
                                                       @Nonnull
                                                       Supplier<? extends String> aName)
```
Check that the passed map is neither null nor empty and that no null key or value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The map to check. May be null.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value. Maybe null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null key or null value is contained

notNullNoNullValue
```
public static <T> T[] notNullNoNullValue(T[] aValue,
                                         String sName)
```
Check that the passed Array is not null and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is null or a null value is contained

notNullNoNullValue
```
public static <T> T[] notNullNoNullValue(T[] aValue,
                                         @Nonnull
                                         Supplier<? extends String> aName)
```
Check that the passed Array is not null and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is null or a null value is contained

notNullNoNullValue
```
public static <T extends Iterable<?>> T notNullNoNullValue(T aValue,
                                                           String sName)
```
Check that the passed collection is not null and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The collection to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is null or a null value is contained

notNullNoNullValue

public static <T extends Iterable<?>> T notNullNoNullValue(T aValue,
                                                           @Nonnull
                                                           Supplier<? extends String> aName)

Check that the passed collection is not null and that no null value is contained.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The collection to check.; aName - The name of the value (e.g. the parameter name)
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is null or a null value is contained

notNullNoNullValue
```
@CodingStyleguideUnaware
public static <T extends Map<?,?>> T notNullNoNullValue(T aValue,
                                                              String sName)
```
Check that the passed map is not null and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The map to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is null or a null value is contained

notNullNoNullValue

@CodingStyleguideUnaware
public static <T extends Map<?,?>> T notNullNoNullValue(T aValue,
                                                              @Nonnull
                                                              Supplier<? extends String> aName)

Check that the passed map is not null and that no null value is contained.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The map to check.; aName - The name of the value (e.g. the parameter name)
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is null or a null value is contained

notEmptyNoNullValue
```
public static <T> T[] notEmptyNoNullValue(T[] aValue,
                                          String sName)
```
Check that the passed Array is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notEmptyNoNullValue
```
public static <T> T[] notEmptyNoNullValue(T[] aValue,
                                          @Nonnull
                                          Supplier<? extends String> aName)
```
Check that the passed Array is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notEmptyNoNullValue
```
public static <T extends Iterable<?>> T notEmptyNoNullValue(T aValue,
                                                            String sName)
```
Check that the passed collection is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The collection to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notEmptyNoNullValue
```
public static <T extends Iterable<?>> T notEmptyNoNullValue(T aValue,
                                                            @Nonnull
                                                            Supplier<? extends String> aName)
```
Check that the passed collection is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The collection to check.

aName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notEmptyNoNullValue
```
@CodingStyleguideUnaware
public static <T extends Map<?,?>> T notEmptyNoNullValue(T aValue,
                                                               String sName)
```
Check that the passed map is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The map to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notEmptyNoNullValue

@CodingStyleguideUnaware
public static <T extends Map<?,?>> T notEmptyNoNullValue(T aValue,
                                                               @Nonnull
                                                               Supplier<? extends String> aName)

Check that the passed map is neither null nor empty and that no null value is contained.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The map to check.; aName - The name of the value (e.g. the parameter name)
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is empty or a null value is contained

notNullNotEquals
```
public static <T> T notNullNotEquals(T aValue,
                                     String sName,
                                     @Nonnull
                                     T aUnexpectedValue)
```
Check that the passed value is not null and not equal to the provided value.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check. May not be null.

sName - The name of the value (e.g. the parameter name)

aUnexpectedValue - The value that may not be equal to aValue. May not be null.

Returns:

The passed value.

notNullNotEquals

public static <T> T notNullNotEquals(T aValue,
                                     @Nonnull
                                     Supplier<? extends String> aName,
                                     @Nonnull
                                     T aUnexpectedValue)

Check that the passed value is not null and not equal to the provided value.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The value to check. May not be null.; aName - The name of the value (e.g. the parameter name); aUnexpectedValue - The value that may not be equal to aValue. May not be null.
Returns:: The passed value.

notNullAndEquals
```
public static <T> T notNullAndEquals(T aValue,
                                     String sName,
                                     @Nonnull
                                     T aExpectedValue)
```
Check that the passed value is not null and equal to the provided expected value.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

aExpectedValue - The expected value. May not be null.

Returns:

The passed value.

Throws:

IllegalArgumentException - if the passed value is not null.

notNullAndEquals

public static <T> T notNullAndEquals(T aValue,
                                     @Nonnull
                                     Supplier<? extends String> aName,
                                     @Nonnull
                                     T aExpectedValue)

Check that the passed value is not null and equal to the provided expected value.

Type Parameters:: T - Type to be checked and returned
Parameters:: aValue - The value to check.; aName - The name of the value (e.g. the parameter name); aExpectedValue - The expected value. May not be null.
Returns:: The passed value.
Throws:: IllegalArgumentException - if the passed value is not null.

isSame
```
public static <T> T isSame(T aValue,
                           String sName,
                           @Nullable
                           T aExpectedValue)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

aExpectedValue - The expected value. May be null.

Returns:

The passed value and maybe null if the expected value is null.

Throws:

IllegalArgumentException - if the passed value is not null.

isSame
```
public static <T> T isSame(T aValue,
                           @Nonnull
                           Supplier<? extends String> aName,
                           @Nullable
                           T aExpectedValue)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

aName - The name of the value (e.g. the parameter name)

aExpectedValue - The expected value. May be null.

Returns:

The passed value and maybe null if the expected value is null.

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static <T> T isEqual(T aValue,
                            @Nullable
                            T aExpectedValue,
                            String sName)
```
Check that the passed value is the same as the provided expected value using equals to check comparison.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

aExpectedValue - The expected value. May be null.

Returns:

The passed value and maybe null if the expected value is null.

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static <T> T isEqual(T aValue,
                            @Nullable
                            T aExpectedValue,
                            @Nonnull
                            Supplier<? extends String> aName)
```
Check that the passed value is the same as the provided expected value using equals to check comparison.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

aName - The name of the value (e.g. the parameter name)

aExpectedValue - The expected value. May be null.

Returns:

The passed value and maybe null if the expected value is null.

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static void isEqual(int nValue,
                           int nExpectedValue,
                           String sName)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Parameters:

nValue - The First value.

nExpectedValue - The expected value.

sName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static void isEqual(int nValue,
                           int nExpectedValue,
                           @Nonnull
                           Supplier<? extends String> aName)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Parameters:

nValue - The First value.

nExpectedValue - The expected value.

aName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static void isEqual(long nValue,
                           long nExpectedValue,
                           String sName)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Parameters:

nValue - The First value.

nExpectedValue - The expected value.

sName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static void isEqual(long nValue,
                           long nExpectedValue,
                           @Nonnull
                           Supplier<? extends String> aName)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Parameters:

nValue - The First value.

nExpectedValue - The expected value.

aName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static void isEqual(double dValue,
                           double dExpectedValue,
                           String sName)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Parameters:

dValue - The First value.

dExpectedValue - The expected value.

sName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

isEqual
```
public static void isEqual(double dValue,
                           double dExpectedValue,
                           @Nonnull
                           Supplier<? extends String> aName)
```
Check that the passed value is the same as the provided expected value using == to check comparison.

Parameters:

dValue - The First value.

dExpectedValue - The expected value.

aName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

isGE0

public static int isGE0(int nValue,
                        String sName)

isGE0

public static int isGE0(int nValue,
                        @Nonnull
                        Supplier<? extends String> aName)

isGE0

public static long isGE0(long nValue,
                         String sName)

isGE0

public static long isGE0(long nValue,
                         @Nonnull
                         Supplier<? extends String> aName)

isGE0

public static short isGE0(short nValue,
                          String sName)

isGE0

public static short isGE0(short nValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isGE0

public static double isGE0(double dValue,
                           String sName)

isGE0

public static double isGE0(double dValue,
                           @Nonnull
                           Supplier<? extends String> aName)

isGE0

public static float isGE0(float fValue,
                          String sName)

isGE0

public static float isGE0(float fValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isGE0

public static BigDecimal isGE0(BigDecimal aValue,
                               String sName)

isGE0

public static BigDecimal isGE0(BigDecimal aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isGE0

public static BigInteger isGE0(BigInteger aValue,
                               String sName)

isGE0

public static BigInteger isGE0(BigInteger aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isGT0

public static int isGT0(int nValue,
                        String sName)

isGT0

public static int isGT0(int nValue,
                        @Nonnull
                        Supplier<? extends String> aName)

isGT0

public static long isGT0(long nValue,
                         String sName)

isGT0

public static long isGT0(long nValue,
                         @Nonnull
                         Supplier<? extends String> aName)

isGT0

public static short isGT0(short nValue,
                          String sName)

isGT0

public static short isGT0(short nValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isGT0

public static double isGT0(double dValue,
                           String sName)

isGT0

public static double isGT0(double dValue,
                           @Nonnull
                           Supplier<? extends String> aName)

isGT0

public static float isGT0(float fValue,
                          String sName)

isGT0

public static float isGT0(float fValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isGT0

public static BigDecimal isGT0(BigDecimal aValue,
                               String sName)

isGT0

public static BigDecimal isGT0(BigDecimal aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isGT0

public static BigInteger isGT0(BigInteger aValue,
                               String sName)

isGT0

public static BigInteger isGT0(BigInteger aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isNE0

public static int isNE0(int nValue,
                        String sName)

isNE0

public static int isNE0(int nValue,
                        @Nonnull
                        Supplier<? extends String> aName)

isNE0

public static long isNE0(long nValue,
                         String sName)

isNE0

public static long isNE0(long nValue,
                         @Nonnull
                         Supplier<? extends String> aName)

isNE0

public static double isNE0(double dValue,
                           String sName)

isNE0

public static double isNE0(double dValue,
                           @Nonnull
                           Supplier<? extends String> aName)

isNE0

public static BigDecimal isNE0(BigDecimal aValue,
                               String sName)

isNE0

public static BigDecimal isNE0(BigDecimal aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isNE0

public static BigInteger isNE0(BigInteger aValue,
                               String sName)

isNE0

public static BigInteger isNE0(BigInteger aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isLE0

public static int isLE0(int nValue,
                        String sName)

isLE0

public static int isLE0(int nValue,
                        @Nonnull
                        Supplier<? extends String> aName)

isLE0

public static long isLE0(long nValue,
                         String sName)

isLE0

public static long isLE0(long nValue,
                         @Nonnull
                         Supplier<? extends String> aName)

isLE0

public static short isLE0(short nValue,
                          String sName)

isLE0

public static short isLE0(short nValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isLE0

public static double isLE0(double dValue,
                           String sName)

isLE0

public static double isLE0(double dValue,
                           @Nonnull
                           Supplier<? extends String> aName)

isLE0

public static float isLE0(float fValue,
                          String sName)

isLE0

public static float isLE0(float fValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isLE0

public static BigDecimal isLE0(BigDecimal aValue,
                               String sName)

isLE0

public static BigDecimal isLE0(BigDecimal aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isLE0

public static BigInteger isLE0(BigInteger aValue,
                               String sName)

isLE0

public static BigInteger isLE0(BigInteger aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isLT0

public static int isLT0(int nValue,
                        String sName)

isLT0

public static int isLT0(int nValue,
                        @Nonnull
                        Supplier<? extends String> aName)

isLT0

public static long isLT0(long nValue,
                         String sName)

isLT0

public static long isLT0(long nValue,
                         @Nonnull
                         Supplier<? extends String> aName)

isLT0

public static short isLT0(short nValue,
                          String sName)

isLT0

public static short isLT0(short nValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isLT0

public static double isLT0(double dValue,
                           String sName)

isLT0

public static double isLT0(double dValue,
                           @Nonnull
                           Supplier<? extends String> aName)

isLT0

public static float isLT0(float fValue,
                          String sName)

isLT0

public static float isLT0(float fValue,
                          @Nonnull
                          Supplier<? extends String> aName)

isLT0

public static BigDecimal isLT0(BigDecimal aValue,
                               String sName)

isLT0

public static BigDecimal isLT0(BigDecimal aValue,
                               @Nonnull
                               Supplier<? extends String> aName)

isLT0

public static BigInteger isLT0(BigInteger aValue,
                               String sName)