fluent.validation

Class Checks

java.lang.Object

fluent.validation.Checks

public final class Checks
extends Object

Factory of ready to use most frequent conditions. There are typical conditions for following categories: 1. General check builders for simple building of new conditions using predicate and description. 2. General object conditions - e.g. isNull, notNull, equalTo, etc. 3. Generalized logical operators (N-ary oneOf instead of binary or, N-ary allOf instead of binary and) 4. Collection (Iterable) conditions + quantifiers 5. Relational and range conditions for comparables 6. String matching conditions (contains/startWith/endsWith as well as regexp matching) 7. Basic XML conditions (XPath, attribute matching) 8. Floating point comparison using a tolerance 9. Builders for composition or collection of criteria.

Method Summary

Modifier and Type	Method and Description
static Check<Object>	a(Class<?> expectedClass)
static <D> Check<D>	allOf(Check<? super D>... operands)
static <D> Check<D>	allOf(Iterable<Check<? super D>> operands)
static Check<Object>	an(Class<?> expectedClass)
static <D> Check<D>	anyOf(Check<? super D>... operands)
static <D> Check<D>	anyOf(Iterable<Check<? super D>> operands)
static Check<Object>	anything()
static <V> Builder<V,Check<V>>	as(Class<V> type)
static Builder<String,Check<Element>>	attribute(String name)
static <D extends Comparable<D>> Check<D>	between(D left, D right)
static <D> Check<D>	between(D left, D right, Comparator<D> comparator)
static <D> Check<D>	betweenInclude(D left, D right, Comparator<D> comparator)
static Check<BigDecimal>	closeTo(BigDecimal operand, BigDecimal precision)
static Check<Double>	closeTo(double operand, double precision)
static Check<Float>	closeTo(float operand, float precision)
static <D,V> Check<D>	compose(String name, Function<? super D,V> function, Check<? super V> check)
static <D> Check<D>	condition(Predicate<D> predicate, String expectationDescription)
static Check<String>	contains(String substring)
static Check<String>	containsCaseInsensitive(String substring)
static <D> Check<D>	createBuilder()
static <D> Check<D>	createBuilderWith(Check<D> check)
static <D> Check<D[]>	emptyArray() Create matcher of empty array.
static <D> Check<Collection<D>>	emptyCollection() Create matcher of empty collection.
static Check<String>	emptyString()
static Check<String>	endsWith(String suffix)
static Check<String>	endsWithCaseInsensitive(String suffix)
static <D extends Comparable<D>> Check<D>	equalOrLessThan(D operand)
static <D> Check<D>	equalOrLessThan(D operand, Comparator<D> comparator)
static <D extends Comparable<D>> Check<D>	equalOrMoreThan(D operand)
static <D> Check<D>	equalOrMoreThan(D operand, Comparator<D> comparator)
static Check<BigDecimal>	equalTo(BigDecimal expectedValue)
static <D> Check<D>	equalTo(D expectedValue)
static Check<Double>	equalTo(Double expectedValue)
static Check<Float>	equalTo(Float expectedValue)
static Check<String>	equalToCaseInsensitive(String expectedValue)
static <D> Check<Iterable<D>>	every(Check<? super D> check)
static <D> Check<Iterable<D>>	exactItemsInAnyOrder(Check<? super D>... itemChecks)
static <D> Check<Iterable<D>>	exactItemsInAnyOrder(Iterable<Check<? super D>> itemConditions)
static <D> Check<Iterable<D>>	exactItemsInOrder(D... expectedItems)
static <D> Check<Iterable<D>>	exactItemsInOrder(Check<? super D>... itemChecks)
static <D> Check<Iterable<D>>	exactItemsInOrder(Iterable<Check<? super D>> itemConditions)
static <D> Check<Iterable<D>>	exists(Check<? super D> check)
static <D,V> Builder<V,Check<D>>	has(String name, Function<? super D,V> function)
static Check<Element>	hasAttribute(String name)
static <D> Check<Collection<D>>	hasItems(Collection<D> items)
static <D> Check<Collection<D>>	hasItems(D... items)
static <D> Check<Iterable<D>>	hasItemsInAnyOrder(Collection<Check<? super D>> itemChecks)
static <D> Check<Iterable<D>>	hasItemsInAnyOrder(Check<? super D>... itemChecks)
static <D> Check<Iterable<D>>	hasItemsInOrder(Check<? super D>... itemChecks)
static <D> Check<Iterable<D>>	hasItemsInOrder(Iterable<Check<? super D>> itemConditions)
static <D> Check<Collection<D>>	hasSize(int size) Create matcher of collection size.
static Check<Object>	instanceOf(Class<?> expectedClass)
static <D> Check<D>	is(D expectedValue)
static Check<Object>	isA(Class<?> expectedClass)
static Check<Object>	isAn(Class<?> expectedClass)
static Check<Object>	isNull()
static <D extends Comparable<D>> Check<D>	lessThan(D operand)
static <D> Check<D>	lessThan(D operand, Comparator<D> comparator)
static Check<String>	matches(Pattern pattern)
static Check<String>	matchesPattern(String pattern)
static Check<Throwable>	message(Check<? super String> check)
static <D extends Comparable<D>> Check<D>	moreThan(D operand)
static <D> Check<D>	moreThan(D operand, Comparator<D> comparator)
static <D> Check<D>	not(D positiveValue)
static <D> Check<D>	not(Check<D> positiveCheck)
static Check<Object>	notNull()
static <D> Check<D>	nullableCondition(Predicate<D> predicate, String expectationDescription) Define a transparent check using provided predicate and string expectation description.
static <D,V> Builder<V,Check<D>>	nullableHas(String name, Function<? super D,V> function)
static <D> Check<D>	oneOf(Collection<D> alternatives) Create matcher, that matches, if tested object meets one of provided alternatives (or).
static <D> Check<D>	oneOf(D... alternatives) Create matcher, that matches, if tested object meets one of provided alternatives (or).
static <D> Check<D>	require(Check<? super D> requirement, Check<? super D> check)
static <D> Check<D>	requireNotNull(Check<D> check)
static Check<Object>	sameClass(Class<?> expectedClass)
static <D> Check<D>	sameInstance(D expectedInstance)
static Check<String>	startsWith(String prefix)
static Check<String>	startsWithCaseInsensitive(String prefix)
static <D> Check<Collection<D>>	subsetOf(Collection<D> superSet) Create matcher, that matches if tested collection meets subset of provided superset.
static <D> Check<Collection<D>>	subsetOf(D... superSet) Create matcher, that matches if tested collection meets subset of provided superset.
static fluent.validation.ThrowingCheck	throwing(Class<? extends Throwable> condition)
static fluent.validation.ThrowingCheck	throwing(Check<? super Throwable> check)
static <D> Check<D>	transparent(CheckVisitor checkVisitor, Check<D> check)
static <D> Check<D>	which(Check<D> check)
static Check<Document>	xpath(String xpath)

Methods inherited from class java.lang.Object

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

Method Detail

nullableCondition

public static <D> Check<D> nullableCondition(Predicate<D> predicate,
                                             String expectationDescription)

Define a transparent check using provided predicate and string expectation description.

Type Parameters:

D - Type of the data to be tested by the created expectation.

Parameters:

predicate - Predicate used to test the supplied data.

expectationDescription - Function, that provides description of the expectation.

Returns:

New expectation.

require

public static <D> Check<D> require(Check<? super D> requirement,
                                   Check<? super D> check)

requireNotNull

public static <D> Check<D> requireNotNull(Check<D> check)

condition

public static <D> Check<D> condition(Predicate<D> predicate,
                                     String expectationDescription)

not

public static <D> Check<D> not(Check<D> positiveCheck)

not

public static <D> Check<D> not(D positiveValue)

oneOf

public static <D> Check<D> oneOf(Collection<D> alternatives)

Create matcher, that matches, if tested object meets one of provided alternatives (or).

Type Parameters:

D - Type of the data to test using this expectation.

Parameters:

alternatives - Expected alternatives.

Returns:

Expectation with alternatives.

oneOf

@SafeVarargs
public static <D> Check<D> oneOf(D... alternatives)

Create matcher, that matches, if tested object meets one of provided alternatives (or).

Type Parameters:

D - Type of the data to test using this expectation.

Parameters:

alternatives - Expected alternatives.

Returns:

Expectation with alternatives.

anyOf

public static <D> Check<D> anyOf(Iterable<Check<? super D>> operands)

anyOf

@SafeVarargs
public static <D> Check<D> anyOf(Check<? super D>... operands)

allOf

public static <D> Check<D> allOf(Iterable<Check<? super D>> operands)

allOf

@SafeVarargs
public static <D> Check<D> allOf(Check<? super D>... operands)

equalTo

public static <D> Check<D> equalTo(D expectedValue)

is

public static <D> Check<D> is(D expectedValue)

isNull

public static Check<Object> isNull()

notNull

public static Check<Object> notNull()

anything

public static Check<Object> anything()

sameInstance

public static <D> Check<D> sameInstance(D expectedInstance)

instanceOf

public static Check<Object> instanceOf(Class<?> expectedClass)

isA

public static Check<Object> isA(Class<?> expectedClass)

isAn

public static Check<Object> isAn(Class<?> expectedClass)

a

public static Check<Object> a(Class<?> expectedClass)

an

public static Check<Object> an(Class<?> expectedClass)

sameClass

public static Check<Object> sameClass(Class<?> expectedClass)

exists

public static <D> Check<Iterable<D>> exists(Check<? super D> check)

every

public static <D> Check<Iterable<D>> every(Check<? super D> check)

emptyArray

public static <D> Check<D[]> emptyArray()

Create matcher of empty array. It returns true, if tested collection meets null or has no elements.

Type Parameters:

D - Type of the items in the collection to be tested.

Returns:

Empty collection expectation.

emptyCollection

public static <D> Check<Collection<D>> emptyCollection()

Create matcher of empty collection. It returns true, if tested collection meets null or has no elements.

Type Parameters:

D - Type of the items in the collection to be tested.

Returns:

Empty collection expectation.

subsetOf

public static <D> Check<Collection<D>> subsetOf(Collection<D> superSet)

Create matcher, that matches if tested collection meets subset of provided superset.

Type Parameters:

D - Type of the items in the collection to be tested.

Parameters:

superSet - Superset of expected items.

Returns:

Subset expectation.

subsetOf

@SafeVarargs
public static <D> Check<Collection<D>> subsetOf(D... superSet)

Create matcher, that matches if tested collection meets subset of provided superset.

Type Parameters:

D - Type of the items in the collection to be tested.

Parameters:

superSet - Superset of expected items.

Returns:

Subset expectation.

hasSize

public static <D> Check<Collection<D>> hasSize(int size)

Create matcher of collection size. If you want to test for emptiness using size 0, note different behavior from empty() for null. This expectation will fail for it, but empty() will pass.

Type Parameters:

D - Type of the items in the collection to be tested.

Parameters:

size - Expected size of the collection.

Returns:

Collection size expectation.

hasItems

public static <D> Check<Collection<D>> hasItems(Collection<D> items)

hasItems

@SafeVarargs
public static <D> Check<Collection<D>> hasItems(D... items)

hasItemsInOrder

public static <D> Check<Iterable<D>> hasItemsInOrder(Iterable<Check<? super D>> itemConditions)

hasItemsInOrder

@SafeVarargs
public static <D> Check<Iterable<D>> hasItemsInOrder(Check<? super D>... itemChecks)

hasItemsInAnyOrder

public static <D> Check<Iterable<D>> hasItemsInAnyOrder(Collection<Check<? super D>> itemChecks)

hasItemsInAnyOrder

@SafeVarargs
public static <D> Check<Iterable<D>> hasItemsInAnyOrder(Check<? super D>... itemChecks)

exactItemsInOrder

public static <D> Check<Iterable<D>> exactItemsInOrder(Iterable<Check<? super D>> itemConditions)

exactItemsInOrder

@SafeVarargs
public static <D> Check<Iterable<D>> exactItemsInOrder(Check<? super D>... itemChecks)

exactItemsInOrder

@SafeVarargs
public static <D> Check<Iterable<D>> exactItemsInOrder(D... expectedItems)

exactItemsInAnyOrder

public static <D> Check<Iterable<D>> exactItemsInAnyOrder(Iterable<Check<? super D>> itemConditions)

exactItemsInAnyOrder

@SafeVarargs
public static <D> Check<Iterable<D>> exactItemsInAnyOrder(Check<? super D>... itemChecks)

compose

public static <D,V> Check<D> compose(String name,
                                     Function<? super D,V> function,
                                     Check<? super V> check)

has

public static <D,V> Builder<V,Check<D>> has(String name,
                                            Function<? super D,V> function)

nullableHas

public static <D,V> Builder<V,Check<D>> nullableHas(String name,
                                                    Function<? super D,V> function)

as

public static <V> Builder<V,Check<V>> as(Class<V> type)

xpath

public static Check<Document> xpath(String xpath)
                             throws XPathExpressionException

Throws:

XPathExpressionException

attribute

public static Builder<String,Check<Element>> attribute(String name)

hasAttribute

public static Check<Element> hasAttribute(String name)

equalToCaseInsensitive

public static Check<String> equalToCaseInsensitive(String expectedValue)

emptyString

public static Check<String> emptyString()

startsWith

public static Check<String> startsWith(String prefix)

startsWithCaseInsensitive

public static Check<String> startsWithCaseInsensitive(String prefix)

endsWith

public static Check<String> endsWith(String suffix)

endsWithCaseInsensitive

public static Check<String> endsWithCaseInsensitive(String suffix)

contains

public static Check<String> contains(String substring)

containsCaseInsensitive

public static Check<String> containsCaseInsensitive(String substring)

matches

public static Check<String> matches(Pattern pattern)

matchesPattern

public static Check<String> matchesPattern(String pattern)

message

public static Check<Throwable> message(Check<? super String> check)

lessThan

public static <D> Check<D> lessThan(D operand,
                                    Comparator<D> comparator)

moreThan

public static <D> Check<D> moreThan(D operand,
                                    Comparator<D> comparator)

equalOrLessThan

public static <D> Check<D> equalOrLessThan(D operand,
                                           Comparator<D> comparator)

equalOrMoreThan

public static <D> Check<D> equalOrMoreThan(D operand,
                                           Comparator<D> comparator)

lessThan

public static <D extends Comparable<D>> Check<D> lessThan(D operand)

moreThan

public static <D extends Comparable<D>> Check<D> moreThan(D operand)

equalOrLessThan

public static <D extends Comparable<D>> Check<D> equalOrLessThan(D operand)

equalOrMoreThan

public static <D extends Comparable<D>> Check<D> equalOrMoreThan(D operand)

between

public static <D extends Comparable<D>> Check<D> between(D left,
                                                         D right)

between

public static <D> Check<D> between(D left,
                                   D right,
                                   Comparator<D> comparator)

betweenInclude

public static <D> Check<D> betweenInclude(D left,
                                          D right,
                                          Comparator<D> comparator)

closeTo

public static Check<Double> closeTo(double operand,
                                    double precision)

closeTo

public static Check<Float> closeTo(float operand,
                                   float precision)

closeTo

public static Check<BigDecimal> closeTo(BigDecimal operand,
                                        BigDecimal precision)

equalTo

public static Check<Double> equalTo(Double expectedValue)

equalTo

public static Check<Float> equalTo(Float expectedValue)

equalTo

public static Check<BigDecimal> equalTo(BigDecimal expectedValue)

throwing

public static fluent.validation.ThrowingCheck throwing(Check<? super Throwable> check)

throwing

public static fluent.validation.ThrowingCheck throwing(Class<? extends Throwable> condition)

createBuilder

public static <D> Check<D> createBuilder()

createBuilderWith

public static <D> Check<D> createBuilderWith(Check<D> check)

which

public static <D> Check<D> which(Check<D> check)

transparent

public static <D> Check<D> transparent(CheckVisitor checkVisitor,
                                       Check<D> check)