Uses of Class
org.fest.assertions.core.Condition

Packages that use Condition
org.fest.assertions.api   
org.fest.assertions.api.filter   
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
<T> Condition<T>
Assertions.allOf(Condition<? super T>... conditions)
          Creates a new AllOf
static
<T> Condition<T>
Assertions.allOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AllOf
static
<T> Condition<T>
Assertions.anyOf(Condition<? super 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).
static
<T> Condition<T>
Assertions.anyOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AnyOf
 

Methods in org.fest.assertions.api with parameters of type Condition
static
<T> Condition<T>
Assertions.allOf(Condition<? super T>... conditions)
          Creates a new AllOf
static
<T> Condition<T>
Assertions.anyOf(Condition<? super 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).
 S AbstractIterableAssert.are(Condition<? super T> condition)
          Verifies that each element value satisfies the given condition
 ObjectArrayAssert<T> ObjectArrayAssert.are(Condition<? super T> condition)
          Verifies that each element value satisfies the given condition
 S AbstractIterableAssert.areAtLeast(int times, Condition<? super T> condition)
          Verifies that there is at least n elements in the actual group satisfying the given condition.
 ObjectArrayAssert<T> ObjectArrayAssert.areAtLeast(int times, Condition<? super T> condition)
          Verifies that there is at least n elements in the actual group satisfying the given condition.
 S AbstractIterableAssert.areAtMost(int times, Condition<? super T> condition)
          Verifies that there is at most n elements in the actual group satisfying the given condition.
 ObjectArrayAssert<T> ObjectArrayAssert.areAtMost(int times, Condition<? super T> condition)
          Verifies that there is at most n elements in the actual group satisfying the given condition.
 S AbstractIterableAssert.areExactly(int times, Condition<? super T> condition)
          Verifies that there is exactly n elements in the actual group satisfying the given condition.
 ObjectArrayAssert<T> ObjectArrayAssert.areExactly(int times, Condition<? super T> condition)
          Verifies that there is exactly n elements in the actual group satisfying the given condition.
 S AbstractIterableAssert.areNot(Condition<? super T> condition)
          Verifies that each element value not satisfies the given condition
 ObjectArrayAssert<T> ObjectArrayAssert.areNot(Condition<? super T> condition)
          Verifies that each element value not satisfies the given condition
 S AbstractIterableAssert.areNotAtLeast(int times, Condition<? super T> condition)
          Verifies that there is at least n elements in the actual group not satisfying the given condition.
 ObjectArrayAssert<T> ObjectArrayAssert.areNotAtLeast(int times, Condition<? super T> condition)
          Verifies that there is at least n elements in the actual group not satisfying the given condition.
 S AbstractIterableAssert.areNotAtMost(int times, Condition<? super T> condition)
          Verifies that there is at most n elements in the actual group not satisfying the given condition.
 ObjectArrayAssert<T> ObjectArrayAssert.areNotAtMost(int times, Condition<? super T> condition)
          Verifies that there is at most n elements in the actual group not satisfying the given condition.
 S AbstractIterableAssert.areNotExactly(int times, Condition<? super T> condition)
          Verifies that there is exactly n elements in the actual group not satisfying the given condition.
 ObjectArrayAssert<T> ObjectArrayAssert.areNotExactly(int times, Condition<? super T> condition)
          Verifies that there is exactly n elements in the actual group not satisfying the given condition.
 S AbstractAssert.doesNotHave(Condition<? super A> condition)
          Verifies that the actual value does not satisfy the given condition.
static
<T> DoesNotHave<T>
Assertions.doesNotHave(Condition<? super T> condition)
          Creates a new DoesNotHave.
 S AbstractIterableAssert.doNotHave(Condition<? super T> condition)
          Verifies that each element value not satisfies the given condition
 ObjectArrayAssert<T> ObjectArrayAssert.doNotHave(Condition<? super T> condition)
          Verifies that each element value not satisfies the given condition
 S AbstractIterableAssert.doNotHaveAtLeast(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition).
 ObjectArrayAssert<T> ObjectArrayAssert.doNotHaveAtLeast(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition).
 S AbstractIterableAssert.doNotHaveAtMost(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition).
 ObjectArrayAssert<T> ObjectArrayAssert.doNotHaveAtMost(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition).
 S AbstractIterableAssert.doNotHaveExactly(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition).
 ObjectArrayAssert<T> ObjectArrayAssert.doNotHaveExactly(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition).
 S AbstractAssert.has(Condition<? super A> condition)
          Verifies that the actual value satisfies the given condition.
 S AbstractIterableAssert.have(Condition<? super T> condition)
          Verifies that each element value satisfies the given condition
 ObjectArrayAssert<T> ObjectArrayAssert.have(Condition<? super T> condition)
          Verifies that each element value satisfies the given condition
 S AbstractIterableAssert.haveAtLeast(int times, Condition<? super T> condition)
          This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition).
 ObjectArrayAssert<T> ObjectArrayAssert.haveAtLeast(int times, Condition<? super T> condition)
          This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition).
 S AbstractIterableAssert.haveAtMost(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition).
 ObjectArrayAssert<T> ObjectArrayAssert.haveAtMost(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition).
 S AbstractIterableAssert.haveExactly(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areExactly(int, Condition).
 ObjectArrayAssert<T> ObjectArrayAssert.haveExactly(int times, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areExactly(int, Condition).
 S AbstractAssert.is(Condition<? super A> condition)
          Verifies that the actual value satisfies the given condition.
 S AbstractAssert.isNot(Condition<? super A> condition)
          Verifies that the actual value does not satisfy the given condition.
static
<T> Not<T>
Assertions.not(Condition<? super T> condition)
          Creates a new Not.
 

Method parameters in org.fest.assertions.api with type arguments of type Condition
static
<T> Condition<T>
Assertions.allOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AllOf
static
<T> Condition<T>
Assertions.anyOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AnyOf
 

Uses of Condition in org.fest.assertions.api.filter
 

Methods in org.fest.assertions.api.filter with parameters of type Condition
 Filters<E> Filters.being(Condition<? super E> condition)
          Filter the underlying group, keeping only elements satisfying the given Condition.
Same as Filters.having(Condition) - pick the method you prefer to have the most readable code.
 Filters<E> Filters.having(Condition<? super E> condition)
          Filter the underlying group, keeping only elements satisfying the given Condition.
Same as Filters.being(Condition) - pick the method you prefer to have the most readable code.
 

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 Conditions.
 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
<T> Condition<T>
AllOf.allOf(Condition<? super T>... conditions)
          Creates a new AllOf
static
<T> Condition<T>
AllOf.allOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AllOf
static
<T> Condition<T>
AnyOf.anyOf(Condition<? super T>... conditions)
          Creates a new AnyOf
static
<T> Condition<T>
AnyOf.anyOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AnyOf
 

Methods in org.fest.assertions.condition that return types with arguments of type Condition
protected  Collection<Condition<? super T>> Join.conditions()
          Returns the conditions to join.
 

Methods in org.fest.assertions.condition with parameters of type Condition
static
<T> Condition<T>
AllOf.allOf(Condition<? super T>... conditions)
          Creates a new AllOf
static
<T> Condition<T>
AnyOf.anyOf(Condition<? super T>... conditions)
          Creates a new AnyOf
static
<T> DoesNotHave<T>
DoesNotHave.doesNotHave(Condition<? super T> condition)
          Creates a new DoesNotHave.
static
<T> Not<T>
Not.not(Condition<? super T> condition)
          Creates a new Not.
 

Method parameters in org.fest.assertions.condition with type arguments of type Condition
static
<T> Condition<T>
AllOf.allOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AllOf
static
<T> Condition<T>
AnyOf.anyOf(Iterable<? extends Condition<? super T>> conditions)
          Creates a new AnyOf
 

Constructors in org.fest.assertions.condition with parameters of type Condition
Join(Condition<? super T>... conditions)
          Creates a new Join.
Negative(Condition<? super T> condition)
           
 

Constructor parameters in org.fest.assertions.condition with type arguments of type Condition
Join(Iterable<? extends Condition<? super 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 Descriptable.as(String) since "as" is a keyword in Groovy.
 Condition<T> Condition.describedAs(String newDescription)
          Alias for Descriptable.as(String) since "as" is a keyword in Groovy.
 

Methods in org.fest.assertions.core with parameters of type Condition
 S ObjectEnumerableAssert.are(Condition<? super T> condition)
          Verifies that each element value satisfies the given condition
 S ObjectEnumerableAssert.areAtLeast(int n, Condition<? super T> condition)
          Verifies that there is at least n elements in the actual group satisfying the given condition.
 S ObjectEnumerableAssert.areAtMost(int n, Condition<? super T> condition)
          Verifies that there is at most n elements in the actual group satisfying the given condition.
 S ObjectEnumerableAssert.areExactly(int n, Condition<? super T> condition)
          Verifies that there is exactly n elements in the actual group satisfying the given condition.
 S ObjectEnumerableAssert.areNot(Condition<? super T> condition)
          Verifies that each element value not satisfies the given condition
 S ObjectEnumerableAssert.areNotAtLeast(int n, Condition<? super T> condition)
          Verifies that there is at least n elements in the actual group not satisfying the given condition.
 S ObjectEnumerableAssert.areNotAtMost(int n, Condition<? super T> condition)
          Verifies that there is at most n elements in the actual group not satisfying the given condition.
 S ObjectEnumerableAssert.areNotExactly(int n, Condition<? super T> condition)
          Verifies that there is exactly n elements in the actual group not satisfying the given condition.
 S ExtensionPoints.doesNotHave(Condition<? super A> condition)
          Verifies that the actual value does not satisfy the given condition.
 S ObjectEnumerableAssert.doNotHave(Condition<? super T> condition)
          Verifies that each element value not satisfies the given condition
 S ObjectEnumerableAssert.doNotHaveAtLeast(int n, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition).
 S ObjectEnumerableAssert.doNotHaveAtMost(int n, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition).
 S ObjectEnumerableAssert.doNotHaveExactly(int n, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition).
 S ExtensionPoints.has(Condition<? super A> condition)
          Verifies that the actual value satisfies the given condition.
 S ObjectEnumerableAssert.have(Condition<? super T> condition)
          Verifies that each element value satisfies the given condition
 S ObjectEnumerableAssert.haveAtLeast(int n, Condition<? super T> condition)
          This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition).
 S ObjectEnumerableAssert.haveAtMost(int n, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition).
 S ObjectEnumerableAssert.haveExactly(int n, Condition<? super T> condition)
          This method is an alias ObjectEnumerableAssert.areExactly(int, Condition).
 S ExtensionPoints.is(Condition<? super A> condition)
          Verifies that the actual value satisfies the given condition.
 S ExtensionPoints.isNot(Condition<? super 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 ErrorMessageFactory ElementsShouldBe.elementsShouldBe(Object actual, Object notSatisfies, Condition<?> condition)
          Creates a new ElementsShouldBe.
static ErrorMessageFactory ElementsShouldBeAtLeast.elementsShouldBeAtLeast(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldBeAtLeast.
static ErrorMessageFactory ElementsShouldBeAtMost.elementsShouldBeAtMost(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldBeAtMost.
static ErrorMessageFactory ElementsShouldBeExactly.elementsShouldBeExactly(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldBeExactly.
static ErrorMessageFactory ElementsShouldHave.elementsShouldHave(Object actual, Object notSatisfies, Condition<?> condition)
          Creates a new ElementsShouldHave.
static ErrorMessageFactory ElementsShouldHaveAtLeast.elementsShouldHaveAtLeast(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldHaveAtLeast.
static ErrorMessageFactory ElementsShouldHaveAtMost.elementsShouldHaveAtMost(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldHaveAtMost.
static
<E> ErrorMessageFactory
ElementsShouldHaveExactly.elementsShouldHaveExactly(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldHaveExactly.
static ErrorMessageFactory ElementsShouldNotBe.elementsShouldNotBe(Object actual, Object satisfies, Condition<?> condition)
          Creates a new ElementsShouldNotBe.
static ErrorMessageFactory ElementsShouldNotBeAtLeast.elementsShouldNotBeAtLeast(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldNotBeAtLeast.
static
<E> ErrorMessageFactory
ElementsShouldNotBeAtMost.elementsShouldNotBeAtMost(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldNotBeAtMost.
static
<E> ErrorMessageFactory
ElementsShouldNotBeExactly.elementsShouldNotBeExactly(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldNotBeExactly.
static ErrorMessageFactory ElementsShouldNotHave.elementsShouldNotHave(Object actual, Object notSatisfies, Condition<?> condition)
          Creates a new ElementsShouldNotHave.
static ErrorMessageFactory ElementsShouldNotHaveAtLeast.elementsShouldNotHaveAtLeast(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldNotHaveAtLeast.
static
<E> ErrorMessageFactory
ElementsShouldNotHaveAtMost.elementsShouldNotHaveAtMost(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldNotHaveAtMost.
static
<E> ErrorMessageFactory
ElementsShouldNotHaveExactly.elementsShouldNotHaveExactly(Object actual, int times, Condition<?> condition)
          Creates a new ElementsShouldNotHaveExactly.
static
<T> ErrorMessageFactory
ShouldBe.shouldBe(T actual, Condition<? super T> condition)
          Creates a new ShouldBe.
static ErrorMessageFactory ConditionAndGroupGenericParameterTypeShouldBeTheSame.shouldBeSameGenericBetweenIterableAndCondition(Object actual, Condition<?> condition)
          Creates a new ConditionAndGroupGenericParameterTypeShouldBeTheSame
static
<T> ErrorMessageFactory
ShouldHave.shouldHave(T actual, Condition<? super T> condition)
          Creates a new ShouldHave.
static
<T> ErrorMessageFactory
ShouldNotBe.shouldNotBe(T actual, Condition<? super T> condition)
          Creates a new ShouldNotBe.
static
<T> ErrorMessageFactory
ShouldNotHave.shouldNotHave(T actual, Condition<? super 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
<E> void
ObjectArrays.assertAre(AssertionInfo info, E[] actual, Condition<? super E> condition)
          Assert that each element of given array satisfies the given condition.
<E> void
Iterables.assertAre(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition)
          Assert that each element of given Iterable satisfies the given condition.
<E> void
ObjectArrays.assertAreAtLeast(AssertionInfo info, E[] actual, int n, Condition<? super E> condition)
          Assert that there is at least n array elements satisfying the given condition.
<E> void
Iterables.assertAreAtLeast(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition)
          Assert that there is at least n elements in the actual Iterable satisfying the given condition.
<E> void
ObjectArrays.assertAreAtMost(AssertionInfo info, E[] actual, int n, Condition<? super E> condition)
          Assert that there is at most n array elements satisfying the given condition.
<E> void
Iterables.assertAreAtMost(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition)
          Assert that there is at most n elements in the actual Iterable satisfying the given condition.
<E> void
ObjectArrays.assertAreExactly(AssertionInfo info, E[] actual, int n, Condition<? super E> condition)
          Verifies that there is exactly n array elements satisfying the given condition.
<E> void
Iterables.assertAreExactly(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition)
          Verifies that there is exactly n elements in the actual Iterable satisfying the given condition.
<E> void
ObjectArrays.assertAreNot(AssertionInfo info, E[] actual, Condition<? super E> condition)
          Assert that each element of given array not satisfies the given condition.
<E> void
Iterables.assertAreNot(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition)
          Assert that each element of given Iterable not satisfies the given condition.
<E> void
ObjectArrays.assertAreNotAtLeast(AssertionInfo info, E[] actual, int n, Condition<? super E> condition)
          Assert that there is at least n array elements not satisfying the given condition.
<E> void
Iterables.assertAreNotAtLeast(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition)
          Assert that there is at least n elements in the actual Iterable not satisfying the given condition.
<E> void
ObjectArrays.assertAreNotAtMost(AssertionInfo info, E[] actual, int n, Condition<? super E> condition)
          Verifies that there is at most n array elements not satisfying the given condition.
<E> void
Iterables.assertAreNotAtMost(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition)
          Verifies that there is at most n elements in the actual Iterable not satisfying the given condition.
<E> void
ObjectArrays.assertAreNotExactly(AssertionInfo info, E[] actual, int n, Condition<? super E> condition)
          Verifies that there is exactly n elements in the actual Iterable not satisfying the given condition.
<E> void
Iterables.assertAreNotExactly(AssertionInfo info, Iterable<? extends E> actual, int n, Condition<? super E> condition)
          Verifies that there is exactly n elements in the actual Iterable not satisfying the given condition.
<T> void
Conditions.assertDoesNotHave(AssertionInfo info, T actual, Condition<? super T> condition)
          Asserts that the actual value does not satisfy the given Condition.
<E> void
ObjectArrays.assertDoNotHave(AssertionInfo info, E[] actual, Condition<? super E> condition)
          Assert that each element of given array not satisfies the given condition.
<E> void
Iterables.assertDoNotHave(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition)
          Assert that each element of given Iterable not satisfies the given condition.
<E> void
ObjectArrays.assertDoNotHaveAtLeast(AssertionInfo info, E[] actual, int times, Condition<? super E> condition)
          An alias method of ObjectArrays.assertAreNotAtLeast(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertDoNotHaveAtLeast(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition)
          An alias method of Iterables.assertAreNotAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertDoNotHaveAtMost(AssertionInfo info, E[] actual, int times, Condition<? super E> condition)
          An alias method of ObjectArrays.assertAreNotAtMost(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertDoNotHaveAtMost(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition)
          An alias method of Iterables.assertAreNotAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertDoNotHaveExactly(AssertionInfo info, E[] actual, int times, Condition<? super E> condition)
          An alias method of ObjectArrays.assertAreNotExactly(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertDoNotHaveExactly(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition)
          An alias method of Iterables.assertAreNotExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<T> void
Conditions.assertHas(AssertionInfo info, T actual, Condition<? super T> condition)
          Asserts that the actual value satisfies the given Condition.
<E> void
ObjectArrays.assertHave(AssertionInfo info, E[] actual, Condition<? super E> condition)
          Assert that each element of given array satisfies the given condition.
<E> void
Iterables.assertHave(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition)
          Assert that each element of given Iterable satisfies the given condition.
<E> void
ObjectArrays.assertHaveAtLeast(AssertionInfo info, E[] actual, int times, Condition<? super E> condition)
          An alias method of ObjectArrays.assertAreAtLeast(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertHaveAtLeast(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition)
          An alias method of Iterables.assertAreAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertHaveAtMost(AssertionInfo info, E[] actual, int times, Condition<? super E> condition)
          An alias method of ObjectArrays.assertAreAtMost(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertHaveAtMost(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition)
          An alias method of Iterables.assertAreAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
ObjectArrays.assertHaveExactly(AssertionInfo info, E[] actual, int times, Condition<? super E> condition)
          An alias method of ObjectArrays.assertAreExactly(AssertionInfo, Object[], int, Condition) to provide a richer fluent api (same logic, only error message differs).
<E> void
Iterables.assertHaveExactly(AssertionInfo info, Iterable<? extends E> actual, int times, Condition<? super E> condition)
          An alias method of Iterables.assertAreExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
<T> void
Conditions.assertIs(AssertionInfo info, T actual, Condition<? super T> condition)
          Asserts that the actual value satisfies the given Condition.
<T> void
Conditions.assertIsNot(AssertionInfo info, T actual, Condition<? super T> condition)
          Asserts that the actual value does not satisfy the given Condition.
 void Conditions.assertIsNotNull(Condition<?> condition)
          Asserts the the given Condition is not null.
 



Copyright © 2007-2012 FEST (Fixtures for Easy Software Testing). All Rights Reserved.