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.public abstract class AbstractAssert<S extends AbstractAssert<S,A>,A> extends Object implements Assert<S,A>
Modifier and Type | Field and Description |
---|---|
protected A |
actual |
protected WritableAssertionInfo |
info |
protected S |
myself |
Modifier | Constructor and Description |
---|---|
protected |
AbstractAssert(A actual,
Class<?> selfType) |
Modifier and Type | Method and Description |
---|---|
S |
as(Description description)
Sets the description of this object.
|
S |
as(String description,
Object... args)
Sets the description of this object supporting
String.format(String, Object...) syntax. |
S |
describedAs(Description description)
Alias for
since "as" is a keyword in Groovy. |
S |
describedAs(String description,
Object... args)
Alias for
since "as" is a keyword in Groovy. |
String |
descriptionText()
The description of this assertion set with
describedAs(String, Object...) 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)
Deprecated.
|
protected void |
failWithMessage(String errorMessage,
Object... arguments)
Utility method to ease writing custom assertions classes, you can use format specifiers in error message, they
will be replaced by the given arguments.
|
protected WritableAssertionInfo |
getWritableAssertionInfo()
Exposes the
WritableAssertionInfo used in the current assertion for better extensibility. When writing
your own assertion class, you can use the returned WritableAssertionInfo to change the error message and
still keep the description set by the assertion user. |
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.
|
protected S |
inBinary()
Use binary object representation instead of standard representation in error messages.
|
protected S |
inHexadecimal()
Use hexadecimal object representation instead of standard representation in error messages.
|
S |
is(Condition<? super A> condition)
Verifies that the actual value satisfies the given condition.
|
S |
isEqualTo(Object 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(Iterable<?> values)
Verifies that the actual value is present in the given values.
|
S |
isIn(Object... values)
Verifies that the actual value is present in the given array of 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(Object 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(Iterable<?> values)
Verifies that the actual value is not present in the given values.
|
S |
isNotIn(Object... values)
Verifies that the actual value is not present in the given array of 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(Object 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(Object expected)
Verifies that the actual value is the same as the given one.
|
S |
overridingErrorMessage(String newErrorMessage,
Object... args)
Overrides AssertJ default error message by 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.
|
protected final WritableAssertionInfo info
protected final A actual
protected final S extends AbstractAssert<S,A> myself
protected WritableAssertionInfo getWritableAssertionInfo()
WritableAssertionInfo
used in the current assertion for better extensibility. When writing
your own assertion class, you can use the returned WritableAssertionInfo
to change the error message and
still keep the description set by the assertion user.WritableAssertionInfo
used in the current assertionprotected void failWithMessage(String errorMessage, Object... arguments)
Moreover, this method honors any description (as(String, Object...)
or overridden error message defined by the user (
overridingErrorMessage(String, Object...)
.
Example :
public TolkienCharacterAssert hasName(String name) { // check that actual TolkienCharacter we want to make assertions on is not null. isNotNull(); // check condition if (!actual.getName().equals(name)) { failWithMessage("Expected character's name to be <%s> but was <%s>", name, actual.getName()); } // return the current assertion for method chaining return this; }
errorMessage
- the error message to formatarguments
- the arguments referenced by the format specifiers in the errorMessage string.public S as(String description, Object... args)
String.format(String, Object...)
syntax.
Example :
try { // set a bad age to Mr Frodo which is really 33 years old. frodo.setAge(50); // you can specify a test description with as() method or describedAs(), it supports String format args assertThat(frodo.getAge()).as("check %s's age", frodo.getName()).isEqualTo(33); } catch (AssertionError e) { assertThat(e).hasMessage("[check Frodo's age] expected:<[33]> but was:<[50]>"); }
as
in interface Descriptable<S extends AbstractAssert<S,A>>
description
- the new description to set.args
- optional parameter if description is a format String.this
object.Descriptable.describedAs(String, Object...)
public S as(Description description)
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.
as
in interface Descriptable<S extends AbstractAssert<S,A>>
description
- the new description to set.this
object.Descriptable.describedAs(Description)
protected S inHexadecimal()
assertThat("µµµ").contains("μμμ"); java.lang.AssertionError: Expecting: <"µµµ"> to contain: <"μμμ">With Hexadecimal message:
assertThat("µµµ").inHexadecimal().contains("μμμ"); java.lang.AssertionError: Expecting: <"['00B5', '00B5', '00B5']"> to contain: <"['03BC', '03BC', '03BC']">
this
assertion object.protected S inBinary()
assertThat(1).inBinary().isEqualTo(2); org.junit.ComparisonFailure: Expected :0b00000000_00000000_00000000_00000010 Actual :0b00000000_00000000_00000000_00000001
this
assertion object.public S describedAs(String description, Object... args)
Descriptable.as(String, Object...)
since "as" is a keyword in Groovy.describedAs
in interface Descriptable<S extends AbstractAssert<S,A>>
description
- the new description to set.this
object.public S describedAs(Description description)
Descriptable.as(String, Object...)
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.
describedAs
in interface Descriptable<S extends AbstractAssert<S,A>>
description
- the new description to set.this
object.public S isEqualTo(Object expected)
public S isNotEqualTo(Object other)
isNotEqualTo
in interface Assert<S extends AbstractAssert<S,A>,A>
other
- the given value to compare the actual value to.this
assertion object.public void isNull()
null
.public S isNotNull()
null
.public S isSameAs(Object expected)
public S isNotSameAs(Object other)
isNotSameAs
in interface Assert<S extends AbstractAssert<S,A>,A>
other
- the given value to compare the actual value to.this
assertion object.public S isIn(Object... values)
public S isNotIn(Object... values)
public S isIn(Iterable<?> values)
public S isNotIn(Iterable<?> values)
public S is(Condition<? super A> condition)
ExtensionPoints.has(Condition)
.is
in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.is(Condition)
public S isNot(Condition<? super A> condition)
ExtensionPoints.doesNotHave(Condition)
.isNot
in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.isNot(Condition)
public S has(Condition<? super A> condition)
ExtensionPoints.is(Condition)
.has
in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.is(Condition)
public S doesNotHave(Condition<? super A> condition)
ExtensionPoints.isNot(Condition)
.doesNotHave
in interface ExtensionPoints<S extends AbstractAssert<S,A>,A>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.isNot(Condition)
public S isInstanceOf(Class<?> type)
isInstanceOf
in interface Assert<S extends AbstractAssert<S,A>,A>
type
- the type to check the actual value against.public S isInstanceOfAny(Class<?>... types)
isInstanceOfAny
in interface Assert<S extends AbstractAssert<S,A>,A>
types
- the types to check the actual value against.public S isNotInstanceOf(Class<?> type)
isNotInstanceOf
in interface Assert<S extends AbstractAssert<S,A>,A>
type
- the type to check the actual value against.public S isNotInstanceOfAny(Class<?>... types)
isNotInstanceOfAny
in interface Assert<S extends AbstractAssert<S,A>,A>
types
- the types to check the actual value against.public S hasSameClassAs(Object other)
hasSameClassAs
in interface Assert<S extends AbstractAssert<S,A>,A>
other
- the object to check type against.public S doesNotHaveSameClassAs(Object other)
doesNotHaveSameClassAs
in interface Assert<S extends AbstractAssert<S,A>,A>
other
- the object to check type against.public S isExactlyInstanceOf(Class<?> type)
isExactlyInstanceOf
in interface Assert<S extends AbstractAssert<S,A>,A>
type
- the type to check the actual value against.public S isNotExactlyInstanceOf(Class<?> type)
isNotExactlyInstanceOf
in interface Assert<S extends AbstractAssert<S,A>,A>
type
- the type to check the actual value against.public S isOfAnyClassIn(Class<?>... types)
isOfAnyClassIn
in interface Assert<S extends AbstractAssert<S,A>,A>
types
- the types to check the actual value against.public S isNotOfAnyClassIn(Class<?>... types)
isNotOfAnyClassIn
in interface Assert<S extends AbstractAssert<S,A>,A>
types
- the types to check the actual value against.public String descriptionText()
describedAs(String, Object...)
or describedAs(Description)
.public S overridingErrorMessage(String newErrorMessage, Object... args)
The new error message is built using String.format(String, Object...)
if you provide args parameter (if you
don't, the error message is taken as it is).
Example :
assertThat(player.isRookie()).overridingErrorMessage("Expecting Player <%s> to be a rookie but was not.", player) .isTrue();
newErrorMessage
- the error message that will replace the default one provided by Assertj.args
- the args used to fill error message as in String.format(String, Object...)
.Exception
- see String.format(String, Object...)
exception clause.public S usingComparator(Comparator<? super A> customComparator)
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);
usingComparator
in interface Assert<S extends AbstractAssert<S,A>,A>
customComparator
- the comparator to use for incoming assertion checks.this
assertion object.public S usingDefaultComparator()
This method should be used to disable a custom comparison strategy set by calling Assert.usingComparator(Comparator)
.
usingDefaultComparator
in interface Assert<S extends AbstractAssert<S,A>,A>
this
assertion object.@Deprecated public boolean equals(Object obj)
UnsupportedOperationException
if called. It is easy to accidentally call
Assert.equals(Object)
instead of Assert.isEqualTo(Object)
.equals
in interface Assert<S extends AbstractAssert<S,A>,A>
equals
in class Object
UnsupportedOperationException
- if this method is called.Copyright © 2013-2014 AssertJ. All Rights Reserved.