org.bitbucket.cowwoc.requirements

Class AssertionVerifier

java.lang.Object

org.bitbucket.cowwoc.requirements.AssertionVerifier

All Implemented Interfaces:

Verifier

public final class AssertionVerifier
extends Object
implements Verifier

Verifies requirements of a parameter if assertions are enabled; otherwise, does nothing.

Unlike Requirements, instances of this class can be configured prior to initiating verification. Doing so causes the same configuration to get reused across runs.

Since:

2.0.3

Author:

Gili Tzabari

Constructor Summary

Constructors

Constructor and Description
AssertionVerifier(boolean enabled) Creates a new assertion verifier.

Method Summary

Modifier and Type	Method and Description
AssertionVerifier	addContext(String key, Object value) Appends contextual information to the exception message.
boolean	isEnabled()
BigDecimalRequirements	requireThat(BigDecimal parameter, String name) Same as RequirementVerifier.requireThat(BigDecimal, String) but does nothing if assertions are disabled.
<T> ClassRequirements<T>	requireThat(Class<T> parameter, String name) Same as RequirementVerifier.requireThat(Class, String) but does nothing if assertions are disabled.
<E> CollectionRequirements<E>	requireThat(Collection<E> parameter, String name) Same as RequirementVerifier.requireThat(Collection, String) but does nothing if assertions are disabled.
DoubleRequirements	requireThat(Double parameter, String name) Verifies requirements of a Double.
<K,V> MapRequirements<K,V>	requireThat(Map<K,V> parameter, String name) Same as RequirementVerifier.requireThat(Map, String) but does nothing if assertions are disabled.
ObjectRequirements<Object>	requireThat(Object parameter, String name) Same as RequirementVerifier.requireThat(Object, String) but does nothing if assertions are disabled.
OptionalRequirements	requireThat(Optional<?> parameter, String name) Same as RequirementVerifier.requireThat(Optional, String) but does nothing if assertions are disabled.
PathRequirements	requireThat(Path parameter, String name) Same as RequirementVerifier.requireThat(Path, String) but does nothing if assertions are disabled.
StringRequirements	requireThat(String parameter, String name) Same as RequirementVerifier.requireThat(String, String) but does nothing if assertions are disabled.
<T extends Comparable<? super T>> ComparableRequirements<T>	requireThat(T parameter, String name) Same as RequirementVerifier.requireThat(Comparable, String) but does nothing if assertions are disabled.
<T extends Number & Comparable<? super T>> NumberRequirements<T>	requireThat(T parameter, String name) Same as RequirementVerifier.requireThat(Number, String) but does nothing if assertions are disabled.
UriRequirements	requireThat(URI parameter, String name) Same as RequirementVerifier.requireThat(URI, String) but does nothing if assertions are disabled.
AssertionVerifier	withContext(List<Map.Entry<String,Object>> context) Sets the contextual information to append to the exception message.
AssertionVerifier	withException(Class<? extends RuntimeException> exception) Overrides the type of exception that will get thrown if a requirement fails.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AssertionVerifier

public AssertionVerifier(boolean enabled)

Creates a new assertion verifier.

To look up whether assertions are enabled for a particular class, invoke:

boolean assertionsEnabled = false;
assert (assertionsEnabled = true);

from within the class in question.

Parameters:

enabled - true if assertions are enabled for the class whose requirements are being verified

Method Detail

isEnabled

public boolean isEnabled()

Returns:

true if assertions are enabled

withException

public AssertionVerifier withException(Class<? extends RuntimeException> exception)

Description copied from interface: Verifier

Overrides the type of exception that will get thrown if a requirement fails.

The exception class must define the following constructors:

<init>(String message)
<init>(String message, Throwable cause)

Specified by:

withException in interface Verifier

Parameters:

exception - the type of exception to throw, null to throw the default exception type

Returns:

a verifier with the specified exception override

addContext

@Beta
public AssertionVerifier addContext(String key,
                                           Object value)
                                    throws NullPointerException

Description copied from interface: Verifier

Appends contextual information to the exception message.

Specified by:

addContext in interface Verifier

Parameters:

key - a key

value - a value

Returns:

a verifier with the specified context

Throws:

NullPointerException - if key is null

withContext

@Beta
public AssertionVerifier withContext(List<Map.Entry<String,Object>> context)
                                     throws NullPointerException

Description copied from interface: Verifier

Sets the contextual information to append to the exception message.

Specified by:

withContext in interface Verifier

Parameters:

context - the contextual information

Returns:

a verifier with the specified context

Throws:

NullPointerException - if context is null

requireThat

public ObjectRequirements<Object> requireThat(Object parameter,
                                              String name)
                                       throws NullPointerException,
                                              IllegalArgumentException

Same as RequirementVerifier.requireThat(Object, String) but does nothing if assertions are disabled.

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public <E> CollectionRequirements<E> requireThat(Collection<E> parameter,
                                                 String name)
                                          throws NullPointerException,
                                                 IllegalArgumentException

Same as RequirementVerifier.requireThat(Collection, String) but does nothing if assertions are disabled.

Type Parameters:

E - the type of element in the collection

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public <T extends Comparable<? super T>> ComparableRequirements<T> requireThat(T parameter,
                                                                               String name)
                                                                        throws NullPointerException,
                                                                               IllegalArgumentException

Same as RequirementVerifier.requireThat(Comparable, String) but does nothing if assertions are disabled.

Type Parameters:

T - the type of the number

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public <T extends Number & Comparable<? super T>> NumberRequirements<T> requireThat(T parameter,
                                                                                    String name)
                                                                             throws NullPointerException,
                                                                                    IllegalArgumentException

Same as RequirementVerifier.requireThat(Number, String) but does nothing if assertions are disabled.

Type Parameters:

T - the type of the number

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public DoubleRequirements requireThat(Double parameter,
                                      String name)
                               throws NullPointerException,
                                      IllegalArgumentException

Verifies requirements of a Double.

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public BigDecimalRequirements requireThat(BigDecimal parameter,
                                          String name)
                                   throws NullPointerException,
                                          IllegalArgumentException

Same as RequirementVerifier.requireThat(BigDecimal, String) but does nothing if assertions are disabled.

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public <K,V> MapRequirements<K,V> requireThat(Map<K,V> parameter,
                                              String name)
                                       throws NullPointerException,
                                              IllegalArgumentException

Same as RequirementVerifier.requireThat(Map, String) but does nothing if assertions are disabled.

Type Parameters:

K - the type of key in the map

V - the type of value in the map

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public PathRequirements requireThat(Path parameter,
                                    String name)
                             throws NullPointerException,
                                    IllegalArgumentException

Same as RequirementVerifier.requireThat(Path, String) but does nothing if assertions are disabled.

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public StringRequirements requireThat(String parameter,
                                      String name)
                               throws NullPointerException,
                                      IllegalArgumentException

Same as RequirementVerifier.requireThat(String, String) but does nothing if assertions are disabled.

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public UriRequirements requireThat(URI parameter,
                                   String name)
                            throws NullPointerException,
                                   IllegalArgumentException

Same as RequirementVerifier.requireThat(URI, String) but does nothing if assertions are disabled.

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public <T> ClassRequirements<T> requireThat(Class<T> parameter,
                                            String name)
                                     throws NullPointerException,
                                            IllegalArgumentException

Same as RequirementVerifier.requireThat(Class, String) but does nothing if assertions are disabled.

Type Parameters:

T - the type of class

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty

requireThat

public OptionalRequirements requireThat(Optional<?> parameter,
                                        String name)
                                 throws NullPointerException,
                                        IllegalArgumentException

Same as RequirementVerifier.requireThat(Optional, String) but does nothing if assertions are disabled.

Parameters:

parameter - the value of the parameter

name - the name of the parameter

Returns:

Requirements for the parameter

Throws:

NullPointerException - if name is null

IllegalArgumentException - if name is empty