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> CheckBuilder<V,Check<V>>	as(Class<V> type)
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 extends Comparable<D>> Check<D>	betweenInclusive(D left, D right)
static <D> Check<D>	betweenInclusive(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, Transformation<? super D,V> transformation, Check<? super V> check)
static <D> Check<D>	createBuilder()
static <D> Check<D>	createBuilderWith(Check<D> check)
static <D> CheckDsl<D>	dsl()
static <D> Check<D[]>	emptyArray() Create matcher of empty array.
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 <D,V> CheckBuilder<V,Check<D>>	has(String name, Transformation<? super D,V> transformation)
static <D> Check<D>	check(Predicate<D> predicate, String expectationDescription)
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<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> CheckBuilder<V,Check<D>>	nullableHas(String name, Transformation<? super D,V> transformation)
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 fluent.validation.ThrowingCheck	throwing(Class<? extends Throwable> condition)
static fluent.validation.ThrowingCheck	throwing(Check<? super Throwable> check)
static <D,V> Check<D>	transform(Transformation<? super D,V> transformation, Check<? super V> check)
static <D> Check<D>	which(Check<D> check)

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)

check

public static <D> Check<D> check(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)

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.

transform

public static <D,V> Check<D> transform(Transformation<? super D,V> transformation,
                                       Check<? super V> check)

compose

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

has

public static <D,V> CheckBuilder<V,Check<D>> has(String name,
                                                 Transformation<? super D,V> transformation)

nullableHas

public static <D,V> CheckBuilder<V,Check<D>> nullableHas(String name,
                                                         Transformation<? super D,V> transformation)

as

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

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)

betweenInclusive

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

betweenInclusive

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

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)

dsl

public static <D> CheckDsl<D> dsl()