org.fest.assertions.api
Class AbstractAssert<S extends AbstractAssert<S,A>,A>

java.lang.Object
  extended by org.fest.assertions.api.AbstractAssert<S,A>
Type Parameters:
S - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.
A - the type of the "actual" value.
All Implemented Interfaces:
Assert<S,A>, Descriptable<S>, ExtensionPoints<S,A>
Direct Known Subclasses:
AbstractComparableAssert, AbstractIterableAssert, BooleanArrayAssert, BooleanAssert, ByteArrayAssert, CharArrayAssert, DateAssert, DoubleArrayAssert, FileAssert, FloatArrayAssert, ImageAssert, InputStreamAssert, IntArrayAssert, LongArrayAssert, MapAssert, ObjectArrayAssert, ObjectAssert, ShortArrayAssert, StringAssert, ThrowableAssert

public abstract class AbstractAssert<S extends AbstractAssert<S,A>,A>
extends Object
implements Assert<S,A>

Base class for all assertions.

Author:
Alex Ruiz, Joel Costigliola, Mikhail Mazursky, Nicolas François

Field Summary
protected  A actual
           
protected  S myself
           
 
Constructor Summary
protected AbstractAssert(A actual, Class<?> selfType)
           
 
Method Summary
 S as(Description description)
          Sets the description of this object.
 S as(String description)
          Sets the description of this object.
 S describedAs(Description description)
          Alias for Descriptable.as(String) since "as" is a keyword in Groovy.
 S describedAs(String description)
          Alias for Descriptable.as(String) since "as" is a keyword in Groovy.
 String descriptionText()
          The description of this assertion set with describedAs(String) or describedAs(Description).
 S doesNotHave(Condition<? super A> condition)
          Verifies that the actual value does not satisfy the given condition.
 S doesNotHaveSameClassAs(Object other)
          Verifies that the actual value does not have the same class as the given object.
 boolean equals(Object obj)
          Throws UnsupportedOperationException if called.
 S has(Condition<? super A> condition)
          Verifies that the actual value satisfies the given condition.
 int hashCode()
          Always returns 1.
 S hasSameClassAs(Object other)
          Verifies that the actual value has the same class as the given object.
 S is(Condition<? super A> condition)
          Verifies that the actual value satisfies the given condition.
 S isEqualTo(A expected)
          Verifies that the actual value is equal to the given one.
 S isExactlyInstanceOf(Class<?> type)
          Verifies that the actual value is exactly an instance of the given type.
 S isIn(A... values)
          Verifies that the actual value is present in the given array of values.
 S isIn(Iterable<? extends A> values)
          Verifies that the actual value is present in the given values.
 S isInstanceOf(Class<?> type)
          Verifies that the actual value is an instance of the given type.
 S isInstanceOfAny(Class<?>... types)
          Verifies that the actual value is an instance of any of the given types.
 S isNot(Condition<? super A> condition)
          Verifies that the actual value does not satisfy the given condition.
 S isNotEqualTo(A other)
          Verifies that the actual value is not equal to the given one.
 S isNotExactlyInstanceOf(Class<?> type)
          Verifies that the actual value is not exactly an instance of given type.
 S isNotIn(A... values)
          Verifies that the actual value is not present in the given array of values.
 S isNotIn(Iterable<? extends A> values)
          Verifies that the actual value is not present in the given values.
 S isNotInstanceOf(Class<?> type)
          Verifies that the actual value is not an instance of the given type.
 S isNotInstanceOfAny(Class<?>... types)
          Verifies that the actual value is not an instance of any of the given types.
 S isNotNull()
          Verifies that the actual value is not null.
 S isNotOfAnyClassIn(Class<?>... types)
          Verifies that the actual value type is not in given types.
 S isNotSameAs(A other)
          Verifies that the actual value is not the same as the given one.
 void isNull()
          Verifies that the actual value is null.
 S isOfAnyClassIn(Class<?>... types)
          Verifies that the actual value type is in given types.
 S isSameAs(A expected)
          Verifies that the actual value is the same as the given one.
 S usingComparator(Comparator<? super A> customComparator)
          Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
 S usingDefaultComparator()
          Revert to standard comparison for incoming assertion checks.
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

actual

protected final A actual

myself

protected final S extends AbstractAssert<S,A> myself
Constructor Detail

AbstractAssert

protected AbstractAssert(A actual,
                         Class<?> selfType)
Method Detail

as

public S as(String description)
Sets the description of this object.

Specified by:
as in interface Descriptable<S extends AbstractAssert<S,A>>
Parameters:
description - the new description to set.
Returns:
this object.
See Also:
Descriptable.describedAs(String)

as

public S as(Description description)
Sets the description of this object. To remove or clear the description, pass a EmptyTextDescription as argument.

This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing users to pass their own implementation of a description. For example, a description that creates its value lazily, only when an assertion failure occurs.

Specified by:
as in interface Descriptable<S extends AbstractAssert<S,A>>
Parameters:
description - the new description to set.
Returns:
this object.
See Also:
Descriptable.describedAs(Description)

describedAs

public S describedAs(String description)
Alias for Descriptable.as(String) since "as" is a keyword in Groovy.

Specified by:
describedAs in interface Descriptable<S extends AbstractAssert<S,A>>
Parameters:
description - the new description to set.
Returns:
this object.

describedAs

public S describedAs(Description description)
Alias for Descriptable.as(String) since "as" is a keyword in Groovy. To remove or clear the description, pass a EmptyTextDescription as argument.

This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing users to pass their own implementation of a description. For example, a description that creates its value lazily, only when an assertion failure occurs.

Specified by:
describedAs in interface Descriptable<S extends AbstractAssert<S,A>>
Parameters:
description - the new description to set.
Returns:
this object.

isEqualTo

public S isEqualTo(A expected)
Verifies that the actual value is equal to the given one.

Specified by:
isEqualTo in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
expected - the given value to compare the actual value to.
Returns:
this assertion object.

isNotEqualTo

public S isNotEqualTo(A other)
Verifies that the actual value is not equal to the given one.

Specified by:
isNotEqualTo in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
other - the given value to compare the actual value to.
Returns:
this assertion object.

isNull

public void isNull()
Verifies that the actual value is null.

Specified by:
isNull in interface Assert<S extends AbstractAssert<S,A>,A>

isNotNull

public S isNotNull()
Verifies that the actual value is not null.

Specified by:
isNotNull in interface Assert<S extends AbstractAssert<S,A>,A>
Returns:
this assertion object.

isSameAs

public S isSameAs(A expected)
Verifies that the actual value is the same as the given one.

Specified by:
isSameAs in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
expected - the given value to compare the actual value to.
Returns:
this assertion object.

isNotSameAs

public S isNotSameAs(A other)
Verifies that the actual value is not the same as the given one.

Specified by:
isNotSameAs in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
other - the given value to compare the actual value to.
Returns:
this assertion object.

isIn

public S isIn(A... values)
Verifies that the actual value is present in the given array of values.

Specified by:
isIn in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
values - the given array to search the actual value in.
Returns:
this assertion object.

isNotIn

public S isNotIn(A... values)
Verifies that the actual value is not present in the given array of values.

Specified by:
isNotIn in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
values - the given array to search the actual value in.
Returns:
this assertion object.

isIn

public S isIn(Iterable<? extends A> values)
Verifies that the actual value is present in the given values.

Specified by:
isIn in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
values - the given iterable to search the actual value in.
Returns:
this assertion object.

isNotIn

public S isNotIn(Iterable<? extends A> values)
Verifies that the actual value is not present in the given values.

Specified by:
isNotIn in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
values - the given iterable to search the actual value in.
Returns:
this assertion object.

is

public S is(Condition<? super A> condition)
Verifies that the actual value satisfies the given condition. This method is an alias for ExtensionPoints.has(Condition).

Specified by:
is in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
Parameters:
condition - the given condition.
Returns:
this ExtensionPoints object.
See Also:
ExtensionPoints.is(Condition)

isNot

public S isNot(Condition<? super A> condition)
Verifies that the actual value does not satisfy the given condition. This method is an alias for ExtensionPoints.doesNotHave(Condition).

Specified by:
isNot in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
Parameters:
condition - the given condition.
Returns:
this ExtensionPoints object.
See Also:
ExtensionPoints.isNot(Condition)

has

public S has(Condition<? super A> condition)
Verifies that the actual value satisfies the given condition. This method is an alias for ExtensionPoints.is(Condition).

Specified by:
has in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
Parameters:
condition - the given condition.
Returns:
this ExtensionPoints object.
See Also:
ExtensionPoints.is(Condition)

doesNotHave

public S doesNotHave(Condition<? super A> condition)
Verifies that the actual value does not satisfy the given condition. This method is an alias for ExtensionPoints.isNot(Condition).

Specified by:
doesNotHave in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
Parameters:
condition - the given condition.
Returns:
this ExtensionPoints object.
See Also:
ExtensionPoints.isNot(Condition)

isInstanceOf

public S isInstanceOf(Class<?> type)
Verifies that the actual value is an instance of the given type.

Specified by:
isInstanceOf in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
type - the type to check the actual value against.
Returns:
this assertion object.

isInstanceOfAny

public S isInstanceOfAny(Class<?>... types)
Verifies that the actual value is an instance of any of the given types.

Specified by:
isInstanceOfAny in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
types - the types to check the actual value against.
Returns:
this assertion object.

isNotInstanceOf

public S isNotInstanceOf(Class<?> type)
Verifies that the actual value is not an instance of the given type.

Specified by:
isNotInstanceOf in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
type - the type to check the actual value against.
Returns:
this assertion object.

isNotInstanceOfAny

public S isNotInstanceOfAny(Class<?>... types)
Verifies that the actual value is not an instance of any of the given types.

Specified by:
isNotInstanceOfAny in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
types - the types to check the actual value against.
Returns:
this assertion object.

hasSameClassAs

public S hasSameClassAs(Object other)
Verifies that the actual value has the same class as the given object.

Specified by:
hasSameClassAs in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
other - the object to check type against.
Returns:
this assertion object.

doesNotHaveSameClassAs

public S doesNotHaveSameClassAs(Object other)
Verifies that the actual value does not have the same class as the given object.

Specified by:
doesNotHaveSameClassAs in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
other - the object to check type against.
Returns:
this assertion object.

isExactlyInstanceOf

public S isExactlyInstanceOf(Class<?> type)
Verifies that the actual value is exactly an instance of the given type.

Specified by:
isExactlyInstanceOf in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
type - the type to check the actual value against.
Returns:
this assertion object.

isNotExactlyInstanceOf

public S isNotExactlyInstanceOf(Class<?> type)
Verifies that the actual value is not exactly an instance of given type.

Specified by:
isNotExactlyInstanceOf in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
type - the type to check the actual value against.
Returns:
this assertion object.

isOfAnyClassIn

public S isOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is in given types.

Specified by:
isOfAnyClassIn in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
types - the types to check the actual value against.
Returns:
this assertion object.

isNotOfAnyClassIn

public S isNotOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is not in given types.

Specified by:
isNotOfAnyClassIn in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
types - the types to check the actual value against.
Returns:
this assertion object.

descriptionText

public String descriptionText()
The description of this assertion set with describedAs(String) or describedAs(Description).

Returns:
the description String representation of this assertion.

usingComparator

public S usingComparator(Comparator<? super A> customComparator)
Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.

Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

Examples :

 // frodo and sam are instances of Character with Hobbit race (obviously :).
 // raceComparator implements Comparator<Character> 
 assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam); 
 

Specified by:
usingComparator in interface Assert<S extends AbstractAssert<S,A>,A>
Parameters:
customComparator - the comparator to use for incoming assertion checks.
Returns:
this assertion object.

usingDefaultComparator

public S usingDefaultComparator()
Revert to standard comparison for incoming assertion checks.

This method should be used to disable a custom comparison strategy set by calling Assert.usingComparator(Comparator).

Specified by:
usingDefaultComparator in interface Assert<S extends AbstractAssert<S,A>,A>
Returns:
this assertion object.

equals

public final boolean equals(Object obj)
Throws UnsupportedOperationException if called. It is easy to accidentally call Assert.equals(Object) instead of isEqualTo.

Specified by:
equals in interface Assert<S extends AbstractAssert<S,A>,A>
Overrides:
equals in class Object

hashCode

public final int hashCode()
Always returns 1.

Overrides:
hashCode in class Object
Returns:
1.


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