|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Condition | |
---|---|
org.fest.assertions.api | |
org.fest.assertions.condition | |
org.fest.assertions.core | |
org.fest.assertions.error | |
org.fest.assertions.internal |
Uses of Condition in org.fest.assertions.api |
---|
Methods in org.fest.assertions.api that return Condition | ||
---|---|---|
static
|
Assertions.anyOf(Collection<Condition<T>> conditions)
Creates a new
|
|
static
|
Assertions.anyOf(Condition<T>... conditions)
Only delegate to AnyOf.anyOf(Condition...) so that Assertions offers a full feature entry point to all Fest
Assert features (but you can use AnyOf if you prefer). |
Methods in org.fest.assertions.api with parameters of type Condition | ||
---|---|---|
static
|
Assertions.anyOf(Condition<T>... conditions)
Only delegate to AnyOf.anyOf(Condition...) so that Assertions offers a full feature entry point to all Fest
Assert features (but you can use AnyOf if you prefer). |
|
|
AbstractIterableAssert.are(Condition<E> condition)
Verifies that each element value satisfies the given condition |
|
|
ObjectArrayAssert.are(Condition<E> condition)
Verifies that each element value satisfies the given condition |
|
|
AbstractIterableAssert.areAtLeast(int times,
Condition<E> condition)
Verifies that there is at least n elements in the actual group satisfying the given condition. |
|
|
ObjectArrayAssert.areAtLeast(int times,
Condition<E> condition)
Verifies that there is at least n elements in the actual group satisfying the given condition. |
|
|
AbstractIterableAssert.areAtMost(int times,
Condition<E> condition)
Verifies that there is at most n elements in the actual group satisfying the given condition. |
|
|
ObjectArrayAssert.areAtMost(int times,
Condition<E> condition)
Verifies that there is at most n elements in the actual group satisfying the given condition. |
|
|
AbstractIterableAssert.areExactly(int times,
Condition<E> condition)
Verifies that there is exactly n elements in the actual group satisfying the given condition. |
|
|
ObjectArrayAssert.areExactly(int times,
Condition<E> condition)
Verifies that there is exactly n elements in the actual group satisfying the given condition. |
|
|
AbstractIterableAssert.areNot(Condition<E> condition)
Verifies that each element value not satisfies the given condition |
|
|
ObjectArrayAssert.areNot(Condition<E> condition)
Verifies that each element value not satisfies the given condition |
|
|
AbstractIterableAssert.areNotAtLeast(int times,
Condition<E> condition)
Verifies that there is at least n elements in the actual group not satisfying the given condition. |
|
|
ObjectArrayAssert.areNotAtLeast(int times,
Condition<E> condition)
Verifies that there is at least n elements in the actual group not satisfying the given condition. |
|
|
AbstractIterableAssert.areNotAtMost(int times,
Condition<E> condition)
Verifies that there is at most n elements in the actual group not satisfying the given condition. |
|
|
ObjectArrayAssert.areNotAtMost(int times,
Condition<E> condition)
Verifies that there is at most n elements in the actual group not satisfying the given condition. |
|
|
AbstractIterableAssert.areNotExactly(int times,
Condition<E> condition)
Verifies that there is exactly n elements in the actual group not satisfying the given condition. |
|
|
ObjectArrayAssert.areNotExactly(int times,
Condition<E> condition)
Verifies that there is exactly n elements in the actual group not satisfying the given condition. |
|
S |
AbstractAssert.doesNotHave(Condition<A> condition)
Verifies that the actual value does not satisfy the given condition. |
|
|
AbstractIterableAssert.doNotHave(Condition<E> condition)
Verifies that each element value not satisfies the given condition |
|
|
ObjectArrayAssert.doNotHave(Condition<E> condition)
Verifies that each element value not satisfies the given condition |
|
|
AbstractIterableAssert.doNotHaveAtLeast(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition) . |
|
|
ObjectArrayAssert.doNotHaveAtLeast(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition) . |
|
|
AbstractIterableAssert.doNotHaveAtMost(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition) . |
|
|
ObjectArrayAssert.doNotHaveAtMost(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition) . |
|
|
AbstractIterableAssert.doNotHaveExactly(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition) . |
|
|
ObjectArrayAssert.doNotHaveExactly(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition) . |
|
S |
AbstractAssert.has(Condition<A> condition)
Verifies that the actual value satisfies the given condition. |
|
|
AbstractIterableAssert.have(Condition<E> condition)
Verifies that each element value satisfies the given condition |
|
|
ObjectArrayAssert.have(Condition<E> condition)
Verifies that each element value satisfies the given condition |
|
|
AbstractIterableAssert.haveAtLeast(int times,
Condition<E> condition)
This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition) . |
|
|
ObjectArrayAssert.haveAtLeast(int times,
Condition<E> condition)
This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition) . |
|
|
AbstractIterableAssert.haveAtMost(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition) . |
|
|
ObjectArrayAssert.haveAtMost(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition) . |
|
|
AbstractIterableAssert.haveExactly(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areExactly(int, Condition) . |
|
|
ObjectArrayAssert.haveExactly(int times,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areExactly(int, Condition) . |
|
S |
AbstractAssert.is(Condition<A> condition)
Verifies that the actual value satisfies the given condition. |
|
S |
AbstractAssert.isNot(Condition<A> condition)
Verifies that the actual value does not satisfy the given condition. |
Method parameters in org.fest.assertions.api with type arguments of type Condition | ||
---|---|---|
static
|
Assertions.anyOf(Collection<Condition<T>> conditions)
Creates a new
|
Uses of Condition in org.fest.assertions.condition |
---|
Subclasses of Condition in org.fest.assertions.condition | |
---|---|
class |
AllOf<T>
Returns true if all of the joined conditions is satisfied. |
class |
AnyOf<T>
Returns true if any of the joined conditions is satisfied. |
class |
DoesNotHave<T>
Returns true if the condition is not satisfied. |
class |
Join<T>
Join of two or more s. |
class |
Negative<T>
Inverse the condition. |
class |
Not<T>
Returns true if the condition is not satisfied. |
Methods in org.fest.assertions.condition that return Condition | ||
---|---|---|
static
|
AllOf.allOf(Collection<Condition<T>> conditions)
Creates a new
|
|
static
|
AllOf.allOf(Condition<T>... conditions)
Creates a new
|
|
static
|
AnyOf.anyOf(Collection<Condition<T>> conditions)
Creates a new
|
|
static
|
AnyOf.anyOf(Condition<T>... conditions)
Creates a new
|
Methods in org.fest.assertions.condition that return types with arguments of type Condition | |
---|---|
protected Collection<Condition<T>> |
Join.conditions()
Returns the conditions to join. |
Methods in org.fest.assertions.condition with parameters of type Condition | ||
---|---|---|
static
|
AllOf.allOf(Condition<T>... conditions)
Creates a new
|
|
static
|
AnyOf.anyOf(Condition<T>... conditions)
Creates a new
|
|
static
|
DoesNotHave.doesNotHave(Condition<T> condition)
Creates a new DoesNotHave . |
|
static
|
Not.not(Condition<T> condition)
Creates a new Not . |
Method parameters in org.fest.assertions.condition with type arguments of type Condition | ||
---|---|---|
static
|
AllOf.allOf(Collection<Condition<T>> conditions)
Creates a new
|
|
static
|
AnyOf.anyOf(Collection<Condition<T>> conditions)
Creates a new
|
Constructors in org.fest.assertions.condition with parameters of type Condition | |
---|---|
Join(Condition<T>... conditions)
Creates a new Join . |
|
Negative(Condition<T> condition)
|
Constructor parameters in org.fest.assertions.condition with type arguments of type Condition | |
---|---|
Join(Collection<Condition<T>> conditions)
Creates a new Join . |
Uses of Condition in org.fest.assertions.core |
---|
Methods in org.fest.assertions.core that return Condition | |
---|---|
Condition<T> |
Condition.as(Description newDescription)
Sets the description of this object. |
Condition<T> |
Condition.as(String newDescription)
Sets the description of this object. |
Condition<T> |
Condition.describedAs(Description newDescription)
Alias for since "as" is a keyword in Groovy. |
Condition<T> |
Condition.describedAs(String newDescription)
Alias for since "as" is a keyword in Groovy. |
Methods in org.fest.assertions.core with parameters of type Condition | ||
---|---|---|
|
ObjectEnumerableAssert.are(Condition<E> condition)
Verifies that each element value satisfies the given condition |
|
|
ObjectEnumerableAssert.areAtLeast(int n,
Condition<E> condition)
Verifies that there is at least n elements in the actual group satisfying the given condition. |
|
|
ObjectEnumerableAssert.areAtMost(int n,
Condition<E> condition)
Verifies that there is at most n elements in the actual group satisfying the given condition. |
|
|
ObjectEnumerableAssert.areExactly(int n,
Condition<E> condition)
Verifies that there is exactly n elements in the actual group satisfying the given condition. |
|
|
ObjectEnumerableAssert.areNot(Condition<E> condition)
Verifies that each element value not satisfies the given condition |
|
|
ObjectEnumerableAssert.areNotAtLeast(int n,
Condition<E> condition)
Verifies that there is at least n elements in the actual group not satisfying the given condition. |
|
|
ObjectEnumerableAssert.areNotAtMost(int n,
Condition<E> condition)
Verifies that there is at most n elements in the actual group not satisfying the given condition. |
|
|
ObjectEnumerableAssert.areNotExactly(int n,
Condition<E> condition)
Verifies that there is exactly n elements in the actual group not satisfying the given condition. |
|
S |
ExtensionPoints.doesNotHave(Condition<A> condition)
Verifies that the actual value does not satisfy the given condition. |
|
|
ObjectEnumerableAssert.doNotHave(Condition<E> condition)
Verifies that each element value not satisfies the given condition |
|
|
ObjectEnumerableAssert.doNotHaveAtLeast(int n,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition) . |
|
|
ObjectEnumerableAssert.doNotHaveAtMost(int n,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition) . |
|
|
ObjectEnumerableAssert.doNotHaveExactly(int n,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition) . |
|
S |
ExtensionPoints.has(Condition<A> condition)
Verifies that the actual value satisfies the given condition. |
|
|
ObjectEnumerableAssert.have(Condition<E> condition)
Verifies that each element value satisfies the given condition |
|
|
ObjectEnumerableAssert.haveAtLeast(int n,
Condition<E> condition)
This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition) . |
|
|
ObjectEnumerableAssert.haveAtMost(int n,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition) . |
|
|
ObjectEnumerableAssert.haveExactly(int n,
Condition<E> condition)
This method is an alias ObjectEnumerableAssert.areExactly(int, Condition) . |
|
S |
ExtensionPoints.is(Condition<A> condition)
Verifies that the actual value satisfies the given condition. |
|
S |
ExtensionPoints.isNot(Condition<A> condition)
Verifies that the actual value does not satisfy the given condition. |
Uses of Condition in org.fest.assertions.error |
---|
Methods in org.fest.assertions.error with parameters of type Condition | ||
---|---|---|
static
|
ElementsShouldBe.elementsShouldBe(Object actual,
Object notSatisfies,
Condition<E> condition)
Creates a new ElementsShouldBe . |
|
static
|
ElementsShouldBeAtLeast.elementsShouldBeAtLeast(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldBeAtLeast . |
|
static
|
ElementsShouldBeAtMost.elementsShouldBeAtMost(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldBeAtMost . |
|
static
|
ElementsShouldBeExactly.elementsShouldBeExactly(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldBeExactly . |
|
static
|
ElementsShouldHave.elementsShouldHave(Object actual,
Object notSatisfies,
Condition<E> condition)
Creates a new ElementsShouldHave . |
|
static
|
ElementsShouldHaveAtLeast.elementsShouldHaveAtLeast(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldHaveAtLeast . |
|
static
|
ElementsShouldHaveAtMost.elementsShouldHaveAtMost(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldHaveAtMost . |
|
static
|
ElementsShouldHaveExactly.elementsShouldHaveExactly(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldHaveExactly . |
|
static
|
ElementsShouldNotBe.elementsShouldNotBe(Object actual,
Object satisfies,
Condition<E> condition)
Creates a new ElementsShouldNotBe . |
|
static
|
ElementsShouldNotBeAtLeast.elementsShouldNotBeAtLeast(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldNotBeAtLeast . |
|
static
|
ElementsShouldNotBeAtMost.elementsShouldNotBeAtMost(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldNotBeAtMost . |
|
static
|
ElementsShouldNotBeExactly.elementsShouldNotBeExactly(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldNotBeExactly . |
|
static
|
ElementsShouldNotHave.elementsShouldNotHave(Object actual,
Object notSatisfies,
Condition<E> condition)
Creates a new ElementsShouldNotHave . |
|
static
|
ElementsShouldNotHaveAtLeast.elementsShouldNotHaveAtLeast(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldNotHaveAtLeast . |
|
static
|
ElementsShouldNotHaveAtMost.elementsShouldNotHaveAtMost(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldNotHaveAtMost . |
|
static
|
ElementsShouldNotHaveExactly.elementsShouldNotHaveExactly(Object actual,
int times,
Condition<E> condition)
Creates a new ElementsShouldNotHaveExactly . |
|
static
|
ShouldBe.shouldBe(T actual,
Condition<T> condition)
Creates a new ShouldBe . |
|
static
|
ConditionAndGroupGenericParameterTypeShouldBeTheSame.shouldBeSameGenericBetweenIterableAndCondition(Object actual,
Condition<E> condition)
Creates a new ConditionAndGroupGenericParameterTypeShouldBeTheSame |
|
static
|
ShouldHave.shouldHave(T actual,
Condition<T> condition)
Creates a new ShouldHave . |
|
static
|
ShouldNotBe.shouldNotBe(T actual,
Condition<T> condition)
Creates a new ShouldNotBe . |
|
static
|
ShouldNotHave.shouldNotHave(T actual,
Condition<T> condition)
Creates a new ShouldNotHave . |
Constructors in org.fest.assertions.error with parameters of type Condition | |
---|---|
ConditionAndGroupGenericParameterTypeShouldBeTheSame(Object actual,
Condition<?> condition)
|
Uses of Condition in org.fest.assertions.internal |
---|
Methods in org.fest.assertions.internal with parameters of type Condition | ||
---|---|---|
|
Iterables.assertAre(AssertionInfo info,
Iterable<?> actual,
Condition<E> condition)
Assert that each element of given Iterable satisfies the given condition. |
|
|
ObjectArrays.assertAre(AssertionInfo info,
Object[] actual,
Condition<E> condition)
Assert that each element of given array satisfies the given condition. |
|
|
Iterables.assertAreAtLeast(AssertionInfo info,
Iterable<?> actual,
int n,
Condition<E> condition)
Assert that there is at least n elements in the actual Iterable satisfying the given
condition. |
|
|
ObjectArrays.assertAreAtLeast(AssertionInfo info,
Object[] actual,
int n,
Condition<E> condition)
Assert that there is at least n array elements satisfying the given condition. |
|
|
Iterables.assertAreAtMost(AssertionInfo info,
Iterable<?> actual,
int n,
Condition<E> condition)
Assert that there is at most n elements in the actual Iterable satisfying the given
condition. |
|
|
ObjectArrays.assertAreAtMost(AssertionInfo info,
Object[] actual,
int n,
Condition<E> condition)
Assert that there is at most n array elements satisfying the given condition. |
|
|
Iterables.assertAreExactly(AssertionInfo info,
Iterable<?> actual,
int n,
Condition<E> condition)
Verifies that there is exactly n elements in the actual Iterable satisfying the given
condition. |
|
|
ObjectArrays.assertAreExactly(AssertionInfo info,
Object[] actual,
int n,
Condition<E> condition)
Verifies that there is exactly n array elements satisfying the given condition. |
|
|
Iterables.assertAreNot(AssertionInfo info,
Iterable<?> actual,
Condition<E> condition)
Assert that each element of given Iterable not satisfies the given condition. |
|
|
ObjectArrays.assertAreNot(AssertionInfo info,
Object[] actual,
Condition<E> condition)
Assert that each element of given array not satisfies the given condition. |
|
|
Iterables.assertAreNotAtLeast(AssertionInfo info,
Iterable<?> actual,
int n,
Condition<E> condition)
Assert that there is at least n elements in the actual Iterable not satisfying the
given condition. |
|
|
ObjectArrays.assertAreNotAtLeast(AssertionInfo info,
Object[] actual,
int n,
Condition<E> condition)
Assert that there is at least n array elements not satisfying the given condition. |
|
|
Iterables.assertAreNotAtMost(AssertionInfo info,
Iterable<?> actual,
int n,
Condition<E> condition)
Verifies that there is at most n elements in the actual Iterable not satisfying the
given condition. |
|
|
ObjectArrays.assertAreNotAtMost(AssertionInfo info,
Object[] actual,
int n,
Condition<E> condition)
Verifies that there is at most n array elements not satisfying the given condition. |
|
|
Iterables.assertAreNotExactly(AssertionInfo info,
Iterable<?> actual,
int n,
Condition<E> condition)
Verifies that there is exactly n elements in the actual Iterable not satisfying the
given condition. |
|
|
ObjectArrays.assertAreNotExactly(AssertionInfo info,
Object[] actual,
int n,
Condition<E> condition)
Verifies that there is exactly n elements in the actual Iterable not satisfying the
given condition. |
|
|
Conditions.assertDoesNotHave(AssertionInfo info,
T actual,
Condition<T> condition)
Asserts that the actual value does not satisfy the given . |
|
|
Iterables.assertDoNotHave(AssertionInfo info,
Iterable<?> actual,
Condition<E> condition)
Assert that each element of given Iterable not satisfies the given condition. |
|
|
ObjectArrays.assertDoNotHave(AssertionInfo info,
Object[] actual,
Condition<E> condition)
Assert that each element of given array not satisfies the given condition. |
|
|
Iterables.assertDoNotHaveAtLeast(AssertionInfo info,
Iterable<?> actual,
int times,
Condition<E> condition)
An alias method of Iterables.assertAreNotAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
|
|
ObjectArrays.assertDoNotHaveAtLeast(AssertionInfo info,
Object[] actual,
int times,
Condition<E> condition)
An alias method of ObjectArrays.assertAreNotAtLeast(AssertionInfo, Object[], int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
|
|
Iterables.assertDoNotHaveAtMost(AssertionInfo info,
Iterable<?> actual,
int times,
Condition<E> condition)
An alias method of Iterables.assertAreNotAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
|
|
ObjectArrays.assertDoNotHaveAtMost(AssertionInfo info,
Object[] actual,
int times,
Condition<E> condition)
An alias method of ObjectArrays.assertAreNotAtMost(AssertionInfo, Object[], int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
|
|
Iterables.assertDoNotHaveExactly(AssertionInfo info,
Iterable<?> actual,
int times,
Condition<E> condition)
An alias method of Iterables.assertAreNotExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent
api (same logic, only error message differs). |
|
|
ObjectArrays.assertDoNotHaveExactly(AssertionInfo info,
Object[] actual,
int times,
Condition<E> condition)
An alias method of ObjectArrays.assertAreNotExactly(AssertionInfo, Object[], int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
|
|
Conditions.assertHas(AssertionInfo info,
T actual,
Condition<T> condition)
Asserts that the actual value satisfies the given . |
|
|
Iterables.assertHave(AssertionInfo info,
Iterable<?> actual,
Condition<E> condition)
Assert that each element of given Iterable satisfies the given condition. |
|
|
ObjectArrays.assertHave(AssertionInfo info,
Object[] actual,
Condition<E> condition)
Assert that each element of given array satisfies the given condition. |
|
|
Iterables.assertHaveAtLeast(AssertionInfo info,
Iterable<?> actual,
int times,
Condition<E> condition)
An alias method of Iterables.assertAreAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
|
|
ObjectArrays.assertHaveAtLeast(AssertionInfo info,
Object[] actual,
int times,
Condition<E> condition)
An alias method of ObjectArrays.assertAreAtLeast(AssertionInfo, Object[], int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
|
|
Iterables.assertHaveAtMost(AssertionInfo info,
Iterable<?> actual,
int times,
Condition<E> condition)
An alias method of Iterables.assertAreAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
|
|
ObjectArrays.assertHaveAtMost(AssertionInfo info,
Object[] actual,
int times,
Condition<E> condition)
An alias method of ObjectArrays.assertAreAtMost(AssertionInfo, Object[], int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
|
|
Iterables.assertHaveExactly(AssertionInfo info,
Iterable<?> actual,
int times,
Condition<E> condition)
An alias method of Iterables.assertAreExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
|
|
ObjectArrays.assertHaveExactly(AssertionInfo info,
Object[] actual,
int times,
Condition<E> condition)
An alias method of ObjectArrays.assertAreExactly(AssertionInfo, Object[], int, Condition) to provide a richer fluent api
(same logic, only error message differs). |
|
|
Conditions.assertIs(AssertionInfo info,
T actual,
Condition<T> condition)
Asserts that the actual value satisfies the given . |
|
|
Conditions.assertIsNot(AssertionInfo info,
T actual,
Condition<T> condition)
Asserts that the actual value does not satisfy the given . |
|
void |
Conditions.assertIsNotNull(Condition<?> condition)
Asserts the the given is not null. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |