Package org.assertj.core.api

Class AbstractPredicateAssert<SELF extends AbstractPredicateAssert<SELF,T>,T>

java.lang.Object

org.assertj.core.api.AbstractAssert<SELF,Predicate<T>>

org.assertj.core.api.AbstractPredicateAssert<SELF,T>

Type Parameters:

T - type of the value contained in the Predicate.

All Implemented Interfaces:

Assert<SELF,Predicate<T>>, Descriptable<SELF>, ExtensionPoints<SELF,Predicate<T>>

Direct Known Subclasses:

PredicateAssert

public abstract class AbstractPredicateAssert<SELF extends AbstractPredicateAssert<SELF,T>,T>
extends AbstractAssert<SELF,Predicate<T>>

Assertions for Predicate.

Author:

Filip Hrisafov

Field Summary

Fields inherited from class org.assertj.core.api.AbstractAssert

actual, info, myself, objects, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	AbstractPredicateAssert(Predicate<T> actual, Class<?> selfType)

Method Summary

Modifier and Type	Method	Description
final SELF	accepts(T... values)	Verifies that the Predicate evaluates all given values to true.
SELF	acceptsAll(Iterable<? extends T> iterable)	Verifies that the Predicate evaluates all given Iterable's elements to true.
protected SELF	acceptsForProxy(T[] values)
final SELF	rejects(T... values)	Verifies that the Predicate evaluates all given values to false.
SELF	rejectsAll(Iterable<? extends T> iterable)	Verifies that the Predicate evaluates all given Iterable's elements to false.
protected SELF	rejectsForProxy(T[] values)

Methods inherited from class org.assertj.core.api.AbstractAssert

areEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, usingRecursiveAssertion, usingRecursiveAssertion, usingRecursiveComparison, usingRecursiveComparison, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.assertj.core.api.Descriptable

as, as, as, describedAs

Constructor Details

AbstractPredicateAssert

protected AbstractPredicateAssert(Predicate<T> actual,
 Class<?> selfType)

Method Details

accepts

@SafeVarargs
public final SELF accepts(T... values)

Verifies that the Predicate evaluates all given values to true.

Example :

 Predicate<String> ballSportPredicate = sport -> sport.contains("ball");

 // assertion succeeds:
 assertThat(ballSportPredicate).accepts("football")
                               .accepts("football", "basketball", "handball");

 // assertions fail because of curling :p
 assertThat(ballSportPredicate).accepts("curling")
 assertThat(ballSportPredicate).accepts("football", "basketball", "curling");

Parameters:

values - values the actual Predicate should accept.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Predicate does not accept all the given Iterable's elements.

acceptsForProxy

protected SELF acceptsForProxy(T[] values)

rejects

@SafeVarargs
public final SELF rejects(T... values)

Verifies that the Predicate evaluates all given values to false.

Example :

 Predicate<String> ballSportPredicate = sport -> sport.contains("ball");

 // assertion succeeds:
 assertThat(ballSportPredicate).rejects("curling")
                               .rejects("curling", "judo", "marathon");

 // assertion fails because of football:
 assertThat(ballSportPredicate).rejects("football");
 assertThat(ballSportPredicate).rejects("curling", "judo", "football");

Parameters:

values - values the actual Predicate should reject.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Predicate accepts one of the given Iterable's elements.

rejectsForProxy

protected SELF rejectsForProxy(T[] values)

acceptsAll

public SELF acceptsAll(Iterable<? extends T> iterable)

Verifies that the Predicate evaluates all given Iterable's elements to true.

Example :

 Predicate<String> ballSportPredicate = sport -> sport.contains("ball");

 // assertion succeeds:
 assertThat(ballSportPredicate).acceptsAll(list("football", "basketball", "handball"));

 // assertion fails because of curling :p
 assertThat(ballSportPredicate).acceptsAll(list("football", "basketball", "curling"));

Parameters:

iterable - Iterable whose elements the actual Predicate should accept.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Predicate does not accept all the given Iterable's elements.

rejectsAll

public SELF rejectsAll(Iterable<? extends T> iterable)

Verifies that the Predicate evaluates all given Iterable's elements to false.

Example :

 Predicate<String> ballSportPredicate = sport -> sport.contains("ball");

 // assertion succeeds:
 assertThat(ballSportPredicate).rejectsAll(list("curling", "judo", "marathon"));

 // assertion fails because of football:
 assertThat(ballSportPredicate).rejectsAll(list("curling", "judo", "football"));

Parameters:

iterable - Iterable whose elements the actual Predicate should reject.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Predicate accepts one of the given Iterable's elements.