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

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
<T> Condition<T>
Assertions.anyOf(Collection<Condition<T>> conditions)
          Creates a new AnyOf
static
<T> Condition<T>
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
<T> Condition<T>
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).
<E> S
AbstractIterableAssert.are(Condition<E> condition)
          Verifies that each element value satisfies the given condition
<E> ObjectArrayAssert
ObjectArrayAssert.are(Condition<E> condition)
          Verifies that each element value satisfies the given condition
<E> S
AbstractIterableAssert.areAtLeast(int times, Condition<E> condition)
          Verifies that there is at least n elements in the actual group satisfying the given condition.
<E> ObjectArrayAssert
ObjectArrayAssert.areAtLeast(int times, Condition<E> condition)
          Verifies that there is at least n elements in the actual group satisfying the given condition.
<E> S
AbstractIterableAssert.areAtMost(int times, Condition<E> condition)
          Verifies that there is at most n elements in the actual group satisfying the given condition.
<E> ObjectArrayAssert
ObjectArrayAssert.areAtMost(int times, Condition<E> condition)
          Verifies that there is at most n elements in the actual group satisfying the given condition.
<E> S
AbstractIterableAssert.areExactly(int times, Condition<E> condition)
          Verifies that there is exactly n elements in the actual group satisfying the given condition.
<E> ObjectArrayAssert
ObjectArrayAssert.areExactly(int times, Condition<E> condition)
          Verifies that there is exactly n elements in the actual group satisfying the given condition.
<E> S
AbstractIterableAssert.areNot(Condition<E> condition)
          Verifies that each element value not satisfies the given condition
<E> ObjectArrayAssert
ObjectArrayAssert.areNot(Condition<E> condition)
          Verifies that each element value not satisfies the given condition
<E> S
AbstractIterableAssert.areNotAtLeast(int times, Condition<E> condition)
          Verifies that there is at least n elements in the actual group not satisfying the given condition.
<E> ObjectArrayAssert
ObjectArrayAssert.areNotAtLeast(int times, Condition<E> condition)
          Verifies that there is at least n elements in the actual group not satisfying the given condition.
<E> S
AbstractIterableAssert.areNotAtMost(int times, Condition<E> condition)
          Verifies that there is at most n elements in the actual group not satisfying the given condition.
<E> ObjectArrayAssert
ObjectArrayAssert.areNotAtMost(int times, Condition<E> condition)
          Verifies that there is at most n elements in the actual group not satisfying the given condition.
<E> S
AbstractIterableAssert.areNotExactly(int times, Condition<E> condition)
          Verifies that there is exactly n elements in the actual group not satisfying the given condition.
<E> ObjectArrayAssert
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.
<E> S
AbstractIterableAssert.doNotHave(Condition<E> condition)
          Verifies that each element value not satisfies the given condition
<E> ObjectArrayAssert
ObjectArrayAssert.doNotHave(Condition<E> condition)
          Verifies that each element value not satisfies the given condition
<E> S
AbstractIterableAssert.doNotHaveAtLeast(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition).
<E> ObjectArrayAssert
ObjectArrayAssert.doNotHaveAtLeast(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition).
<E> S
AbstractIterableAssert.doNotHaveAtMost(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition).
<E> ObjectArrayAssert
ObjectArrayAssert.doNotHaveAtMost(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition).
<E> S
AbstractIterableAssert.doNotHaveExactly(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition).
<E> ObjectArrayAssert
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.
<E> S
AbstractIterableAssert.have(Condition<E> condition)
          Verifies that each element value satisfies the given condition
<E> ObjectArrayAssert
ObjectArrayAssert.have(Condition<E> condition)
          Verifies that each element value satisfies the given condition
<E> S
AbstractIterableAssert.haveAtLeast(int times, Condition<E> condition)
          This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition).
<E> ObjectArrayAssert
ObjectArrayAssert.haveAtLeast(int times, Condition<E> condition)
          This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition).
<E> S
AbstractIterableAssert.haveAtMost(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition).
<E> ObjectArrayAssert
ObjectArrayAssert.haveAtMost(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition).
<E> S
AbstractIterableAssert.haveExactly(int times, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areExactly(int, Condition).
<E> ObjectArrayAssert
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
<T> Condition<T>
Assertions.anyOf(Collection<Condition<T>> conditions)
          Creates a new AnyOf
 

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(Collection<Condition<T>> conditions)
          Creates a new AllOf
static
<T> Condition<T>
AllOf.allOf(Condition<T>... conditions)
          Creates a new AllOf
static
<T> Condition<T>
AnyOf.anyOf(Collection<Condition<T>> conditions)
          Creates a new AnyOf
static
<T> Condition<T>
AnyOf.anyOf(Condition<T>... conditions)
          Creates a new AnyOf
 

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
<T> Condition<T>
AllOf.allOf(Condition<T>... conditions)
          Creates a new AllOf
static
<T> Condition<T>
AnyOf.anyOf(Condition<T>... conditions)
          Creates a new AnyOf
static
<T> DoesNotHave<T>
DoesNotHave.doesNotHave(Condition<T> condition)
          Creates a new DoesNotHave.
static
<T> Not<T>
Not.not(Condition<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(Collection<Condition<T>> conditions)
          Creates a new AllOf
static
<T> Condition<T>
AnyOf.anyOf(Collection<Condition<T>> conditions)
          Creates a new AnyOf
 

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 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
<E> S
ObjectEnumerableAssert.are(Condition<E> condition)
          Verifies that each element value satisfies the given condition
<E> S
ObjectEnumerableAssert.areAtLeast(int n, Condition<E> condition)
          Verifies that there is at least n elements in the actual group satisfying the given condition.
<E> S
ObjectEnumerableAssert.areAtMost(int n, Condition<E> condition)
          Verifies that there is at most n elements in the actual group satisfying the given condition.
<E> S
ObjectEnumerableAssert.areExactly(int n, Condition<E> condition)
          Verifies that there is exactly n elements in the actual group satisfying the given condition.
<E> S
ObjectEnumerableAssert.areNot(Condition<E> condition)
          Verifies that each element value not satisfies the given condition
<E> S
ObjectEnumerableAssert.areNotAtLeast(int n, Condition<E> condition)
          Verifies that there is at least n elements in the actual group not satisfying the given condition.
<E> S
ObjectEnumerableAssert.areNotAtMost(int n, Condition<E> condition)
          Verifies that there is at most n elements in the actual group not satisfying the given condition.
<E> S
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.
<E> S
ObjectEnumerableAssert.doNotHave(Condition<E> condition)
          Verifies that each element value not satisfies the given condition
<E> S
ObjectEnumerableAssert.doNotHaveAtLeast(int n, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition).
<E> S
ObjectEnumerableAssert.doNotHaveAtMost(int n, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition).
<E> S
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.
<E> S
ObjectEnumerableAssert.have(Condition<E> condition)
          Verifies that each element value satisfies the given condition
<E> S
ObjectEnumerableAssert.haveAtLeast(int n, Condition<E> condition)
          This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition).
<E> S
ObjectEnumerableAssert.haveAtMost(int n, Condition<E> condition)
          This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition).
<E> S
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
<E> ErrorMessageFactory
ElementsShouldBe.elementsShouldBe(Object actual, Object notSatisfies, Condition<E> condition)
          Creates a new ElementsShouldBe.
static
<E> ErrorMessageFactory
ElementsShouldBeAtLeast.elementsShouldBeAtLeast(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldBeAtLeast.
static
<E> ErrorMessageFactory
ElementsShouldBeAtMost.elementsShouldBeAtMost(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldBeAtMost.
static
<E> ErrorMessageFactory
ElementsShouldBeExactly.elementsShouldBeExactly(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldBeExactly.
static
<E> ErrorMessageFactory
ElementsShouldHave.elementsShouldHave(Object actual, Object notSatisfies, Condition<E> condition)
          Creates a new ElementsShouldHave.
static
<E> ErrorMessageFactory
ElementsShouldHaveAtLeast.elementsShouldHaveAtLeast(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldHaveAtLeast.
static
<E> ErrorMessageFactory
ElementsShouldHaveAtMost.elementsShouldHaveAtMost(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldHaveAtMost.
static
<E> ErrorMessageFactory
ElementsShouldHaveExactly.elementsShouldHaveExactly(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldHaveExactly.
static
<E> ErrorMessageFactory
ElementsShouldNotBe.elementsShouldNotBe(Object actual, Object satisfies, Condition<E> condition)
          Creates a new ElementsShouldNotBe.
static
<E> ErrorMessageFactory
ElementsShouldNotBeAtLeast.elementsShouldNotBeAtLeast(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldNotBeAtLeast.
static
<E> ErrorMessageFactory
ElementsShouldNotBeAtMost.elementsShouldNotBeAtMost(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldNotBeAtMost.
static
<E> ErrorMessageFactory
ElementsShouldNotBeExactly.elementsShouldNotBeExactly(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldNotBeExactly.
static
<E> ErrorMessageFactory
ElementsShouldNotHave.elementsShouldNotHave(Object actual, Object notSatisfies, Condition<E> condition)
          Creates a new ElementsShouldNotHave.
static
<E> ErrorMessageFactory
ElementsShouldNotHaveAtLeast.elementsShouldNotHaveAtLeast(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldNotHaveAtLeast.
static
<E> ErrorMessageFactory
ElementsShouldNotHaveAtMost.elementsShouldNotHaveAtMost(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldNotHaveAtMost.
static
<E> ErrorMessageFactory
ElementsShouldNotHaveExactly.elementsShouldNotHaveExactly(Object actual, int times, Condition<E> condition)
          Creates a new ElementsShouldNotHaveExactly.
static
<T> ErrorMessageFactory
ShouldBe.shouldBe(T actual, Condition<T> condition)
          Creates a new ShouldBe.
static
<E> ErrorMessageFactory
ConditionAndGroupGenericParameterTypeShouldBeTheSame.shouldBeSameGenericBetweenIterableAndCondition(Object actual, Condition<E> condition)
          Creates a new ConditionAndGroupGenericParameterTypeShouldBeTheSame
static
<T> ErrorMessageFactory
ShouldHave.shouldHave(T actual, Condition<T> condition)
          Creates a new ShouldHave.
static
<T> ErrorMessageFactory
ShouldNotBe.shouldNotBe(T actual, Condition<T> condition)
          Creates a new ShouldNotBe.
static
<T> ErrorMessageFactory
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
<E> void
Iterables.assertAre(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable satisfies the given condition.
<E> void
ObjectArrays.assertAre(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array satisfies the given condition.
<E> void
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.
<E> void
ObjectArrays.assertAreAtLeast(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Assert that there is at least n array elements satisfying the given condition.
<E> void
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.
<E> void
ObjectArrays.assertAreAtMost(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Assert that there is at most n array elements satisfying the given condition.
<E> void
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.
<E> void
ObjectArrays.assertAreExactly(AssertionInfo info, Object[] actual, int n, Condition<E> condition)
          Verifies that there is exactly n array elements satisfying the given condition.
<E> void
Iterables.assertAreNot(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable not satisfies the given condition.
<E> void
ObjectArrays.assertAreNot(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array not satisfies the given condition.
<E> void
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.
<E> void
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.
<E> void
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.
<E> void
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.
<E> void
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.
<E> void
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.
<T> void
Conditions.assertDoesNotHave(AssertionInfo info, T actual, Condition<T> condition)
          Asserts that the actual value does not satisfy the given Condition.
<E> void
Iterables.assertDoNotHave(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable not satisfies the given condition.
<E> void
ObjectArrays.assertDoNotHave(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array not satisfies the given condition.
<E> void
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).
<E> void
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).
<E> void
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).
<E> void
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).
<E> void
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).
<E> void
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).
<T> void
Conditions.assertHas(AssertionInfo info, T actual, Condition<T> condition)
          Asserts that the actual value satisfies the given Condition.
<E> void
Iterables.assertHave(AssertionInfo info, Iterable<?> actual, Condition<E> condition)
          Assert that each element of given Iterable satisfies the given condition.
<E> void
ObjectArrays.assertHave(AssertionInfo info, Object[] actual, Condition<E> condition)
          Assert that each element of given array satisfies the given condition.
<E> void
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).
<E> void
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).
<E> void
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).
<E> void
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).
<E> void
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).
<E> void
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).
<T> void
Conditions.assertIs(AssertionInfo info, T actual, Condition<T> condition)
          Asserts that the actual value satisfies the given Condition.
<T> void
Conditions.assertIsNot(AssertionInfo info, T actual, Condition<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.