SELF
- the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation"
for more details.ACTUAL
- the type of the "actual" value.public abstract class AbstractAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL> extends Object implements Assert<SELF,ACTUAL>
Modifier and Type | Field and Description |
---|---|
protected ACTUAL |
actual |
WritableAssertionInfo |
info |
protected SELF |
myself |
static boolean |
throwUnsupportedExceptionOnEquals |
Constructor and Description |
---|
AbstractAssert(ACTUAL actual,
Class<?> selfType) |
Modifier and Type | Method and Description |
---|---|
SELF |
as(Description description)
Sets the description of the assertion that is going to be called after.
|
SELF |
as(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
asList()
Verifies that the actual value is an instance of List,
and returns a list assertion, to allow chaining of list-specific
assertions from this call.
|
AbstractCharSequenceAssert<?,String> |
asString()
Verifies that the actual value is an instance of String,
and returns a String assertion, to allow chaining of String-specific
assertions from this call.
|
SELF |
describedAs(Description description)
Sets the description of the assertion that is going to be called after.
|
SELF |
describedAs(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
String |
descriptionText()
The description of this assertion set with
describedAs(String, Object...) or
describedAs(Description) . |
SELF |
doesNotHave(Condition<? super ACTUAL> condition)
Verifies that the actual value does not satisfy the given condition.
|
SELF |
doesNotHaveSameClassAs(Object other)
Verifies that the actual value does not have the same class as the given object.
|
boolean |
equals(Object obj)
Deprecated.
use
isEqualTo(java.lang.Object) instead |
protected void |
failWithMessage(String errorMessage,
Object... arguments)
Utility method to ease writing custom assertions classes using
String.format(String, Object...) specifiers
in error message. |
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. |
SELF |
has(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition.
|
int |
hashCode()
Always returns 1.
|
SELF |
hasSameClassAs(Object other)
Verifies that the actual value has the same class as the given object.
|
SELF |
hasSameHashCodeAs(Object other)
Verifies that the actual object has the same hashCode as the given object.
|
SELF |
hasToString(String expectedToString)
Verifies that actual
actual.toString() is equal to the given String . |
protected SELF |
inBinary()
Use binary object representation instead of standard representation in error messages.
|
protected SELF |
inHexadecimal()
Use hexadecimal object representation instead of standard representation in error messages.
|
SELF |
is(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition.
|
SELF |
isEqualTo(Object expected)
Verifies that the actual value is equal to the given one.
|
SELF |
isExactlyInstanceOf(Class<?> type)
Verifies that the actual value is exactly an instance of the given type.
|
SELF |
isIn(Iterable<?> values)
Verifies that the actual value is present in the given values.
|
SELF |
isIn(Object... values)
Verifies that the actual value is present in the given array of values.
|
SELF |
isInstanceOf(Class<?> type)
Verifies that the actual value is an instance of the given type.
|
SELF |
isInstanceOfAny(Class<?>... types)
Verifies that the actual value is an instance of any of the given types.
|
<T> SELF |
isInstanceOfSatisfying(Class<T> type,
Consumer<T> requirements)
Verifies that the actual value is an instance of the given type satisfying the given requirements expressed as a
Consumer . |
SELF |
isNot(Condition<? super ACTUAL> condition)
Verifies that the actual value does not satisfy the given condition.
|
SELF |
isNotEqualTo(Object other)
Verifies that the actual value is not equal to the given one.
|
SELF |
isNotExactlyInstanceOf(Class<?> type)
Verifies that the actual value is not exactly an instance of given type.
|
SELF |
isNotIn(Iterable<?> values)
Verifies that the actual value is not present in the given values.
|
SELF |
isNotIn(Object... values)
Verifies that the actual value is not present in the given array of values.
|
SELF |
isNotInstanceOf(Class<?> type)
Verifies that the actual value is not an instance of the given type.
|
SELF |
isNotInstanceOfAny(Class<?>... types)
Verifies that the actual value is not an instance of any of the given types.
|
SELF |
isNotNull()
Verifies that the actual value is not
null . |
SELF |
isNotOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is not in given types.
|
SELF |
isNotSameAs(Object other)
Verifies that the actual value is not the same as the given one, ie using == comparison.
|
void |
isNull()
Verifies that the actual value is
null . |
SELF |
isOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is in given types.
|
SELF |
isSameAs(Object expected)
Verifies that the actual value is the same as the given one, ie using == comparison.
|
SELF |
matches(Predicate<? super ACTUAL> predicate)
Verifies that the actual object matches the given predicate.
|
SELF |
matches(Predicate<? super ACTUAL> predicate,
String predicateDescription)
Verifies that the actual object matches the given predicate, the predicate description is used to get an
informative error message.
|
protected <E> AbstractListAssert<?,List<? extends E>,E,ObjectAssert<E>> |
newListAssertInstance(List<? extends E> newActual)
Create a
AbstractListAssert . |
SELF |
overridingErrorMessage(String newErrorMessage,
Object... args)
Overrides AssertJ default error message by the given one.
|
SELF |
satisfies(Consumer<ACTUAL> requirements)
Verifies that the actual object satisfied the given requirements expressed as a
Consumer . |
static void |
setCustomRepresentation(Representation customRepresentation) |
protected void |
throwAssertionError(ErrorMessageFactory errorMessageFactory)
Utility method to throw an
AssertionError given a BasicErrorMessageFactory . |
SELF |
usingComparator(Comparator<? super ACTUAL> customComparator)
Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
usingDefaultComparator()
Revert to standard comparison for incoming assertion checks.
|
SELF |
withFailMessage(String newErrorMessage,
Object... args)
Alternative method for
overridingErrorMessage(java.lang.String, java.lang.Object...) |
SELF |
withRepresentation(Representation representation)
Use the given
Representation to describe/represent values in AssertJ error messages. |
SELF |
withThreadDumpOnError()
In case of an assertion error, a thread dump will be printed to
System.err . |
public static boolean throwUnsupportedExceptionOnEquals
public final WritableAssertionInfo info
protected final ACTUAL actual
protected final SELF extends AbstractAssert<SELF,ACTUAL> myself
public WritableAssertionInfo getWritableAssertionInfo()
WritableAssertionInfo
used in the current assertion for better extensibility.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)
String.format(String, Object...)
specifiers
in error message.
Moreover, this method honors any description set with as(String, Object...)
or overridden error message
defined by the user with 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.protected void throwAssertionError(ErrorMessageFactory errorMessageFactory)
AssertionError
given a BasicErrorMessageFactory
.
Instead of writing ...
throw Failures.instance().failure(info, ShouldBePresent.shouldBePresent());
... you can simply write :
throwAssertionError(info, ShouldBePresent.shouldBePresent());
errorMessageFactory
- used to define the error message.AssertionError
- with a message corresponding to the given BasicErrorMessageFactory
.public SELF as(String description, Object... args)
You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
The description follows String.format(String, Object...)
syntax.
Example :
try {
// set a bad age to Mr Frodo which is really 33 years old.
frodo.setAge(50);
// specify a test description (call as() before the assertion !), it supports String format syntax.
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<SELF extends AbstractAssert<SELF,ACTUAL>>
description
- the new description to set.args
- optional parameter if description is a format String.this
object.Descriptable.describedAs(String, Object...)
public SELF as(Description description)
You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
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<SELF extends AbstractAssert<SELF,ACTUAL>>
description
- the new description to set.this
object.Descriptable.describedAs(Description)
protected SELF inHexadecimal()
It can be useful when comparing UNICODE characters - many unicode chars have duplicate characters assigned, it is thus impossible to find differences from the standard error message:
With standard message:
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 SELF inBinary()
Example:
assertThat(1).inBinary().isEqualTo(2);
org.junit.ComparisonFailure:
Expected :0b00000000_00000000_00000000_00000010
Actual :0b00000000_00000000_00000000_00000001
this
assertion object.public SELF describedAs(String description, Object... args)
You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
Alias for
since "as" is a keyword in Groovy.Descriptable.as(String, Object...)
describedAs
in interface Descriptable<SELF extends AbstractAssert<SELF,ACTUAL>>
description
- the new description to set.args
- optional parameter if description is a format String.this
object.public SELF describedAs(Description description)
You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
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<SELF extends AbstractAssert<SELF,ACTUAL>>
description
- the new description to set.this
object.public SELF isEqualTo(Object expected)
Example:
// assertions will pass
assertThat("abc").isEqualTo("abc");
assertThat(new HashMap<String, Integer>()).isEqualTo(new HashMap<String, Integer>());
// assertions will fail
assertThat("abc").isEqualTo("123");
assertThat(new ArrayList<String>()).isEqualTo(1);
public SELF isNotEqualTo(Object other)
Example:
// assertions will pass
assertThat("abc").isNotEqualTo("123");
assertThat(new ArrayList<String>()).isNotEqualTo(1);
// assertions will fail
assertThat("abc").isNotEqualTo("abc");
assertThat(new HashMap<String, Integer>()).isNotEqualTo(new HashMap<String, Integer>());
isNotEqualTo
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
other
- the given value to compare the actual value to.this
assertion object.public void isNull()
null
.
Example:
String value = null;
// assertion will pass
assertThat(value).isNull();
// assertions will fail
assertThat("abc").isNull();
assertThat(new HashMap<String, Integer>()).isNull();
public SELF isNotNull()
null
.
Example:
// assertion will pass
assertThat("abc").isNotNull();
assertThat(new HashMap<String, Integer>()).isNotNull();
// assertion will fail
String value = null;
assertThat(value).isNotNull();
public SELF isSameAs(Object expected)
Example:
// Name is a class with first and last fields, two Names are equals if both first and last are equals.
Name tyrion = new Name("Tyrion", "Lannister");
Name alias = tyrion;
Name clone = new Name("Tyrion", "Lannister");
// assertions succeed:
assertThat(tyrion).isSameAs(alias)
.isEqualTo(clone);
// assertion fails:
assertThat(tyrion).isSameAs(clone);
public SELF isNotSameAs(Object other)
Example:
// Name is a class with first and last fields, two Names are equals if both first and last are equals.
Name tyrion = new Name("Tyrion", "Lannister");
Name alias = tyrion;
Name clone = new Name("Tyrion", "Lannister");
// assertions succeed:
assertThat(clone).isNotSameAs(tyrion)
.isEqualTo(tyrion);
// assertion fails:
assertThat(alias).isNotSameAs(tyrion);
isNotSameAs
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
other
- the given value to compare the actual value to.this
assertion object.public SELF isIn(Object... values)
Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya };
// assertion will pass:
assertThat(nenya).isIn(elvesRings);
// assertion will fail:
assertThat(oneRing).isIn(elvesRings);
public SELF isNotIn(Object... values)
Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya };
// assertion will pass:
assertThat(oneRing).isNotIn(elvesRings);
// assertion will fail:
assertThat(nenya).isNotIn(elvesRings);
public SELF isIn(Iterable<?> values)
Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
// assertion will pass:
assertThat(nenya).isIn(elvesRings);
// assertion will fail:
assertThat(oneRing).isIn(elvesRings);
public SELF isNotIn(Iterable<?> values)
Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
// assertion will pass:
assertThat(oneRing).isNotIn(elvesRings);
// assertion will fail:
assertThat(nenya).isNotIn(elvesRings);
public SELF is(Condition<? super ACTUAL> condition)
ExtensionPoints.has(Condition)
.is
in interface ExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.is(Condition)
public SELF isNot(Condition<? super ACTUAL> condition)
ExtensionPoints.doesNotHave(Condition)
.isNot
in interface ExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.isNot(Condition)
public SELF has(Condition<? super ACTUAL> condition)
ExtensionPoints.is(Condition)
.has
in interface ExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.is(Condition)
public SELF doesNotHave(Condition<? super ACTUAL> condition)
ExtensionPoints.isNot(Condition)
.doesNotHave
in interface ExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
condition
- the given condition.this ExtensionPoints
object.ExtensionPoints.isNot(Condition)
public SELF isInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat("abc").isInstanceOf(String.class);
assertThat(new HashMap<String, Integer>()).isInstanceOf(HashMap.class);
assertThat(new HashMap<String, Integer>()).isInstanceOf(Map.class);
// assertions will fail
assertThat(1).isInstanceOf(String.class);
assertThat(new ArrayList<String>()).isInstanceOf(LinkedList.class);
isInstanceOf
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
type
- the type to check the actual value against.public <T> SELF isInstanceOfSatisfying(Class<T> type, Consumer<T> requirements)
Consumer
.
This is useful to perform a group of assertions on a single object after checking its runtime type.
Example:
// second constructor parameter is the light saber color
Object yoda = new Jedi("Yoda", "Green");
Object luke = new Jedi("Luke Skywalker", "Green");
Consumer<Jedi> jediRequirements = jedi -> {
assertThat(jedi.getLightSaberColor()).isEqualTo("Green");
assertThat(jedi.getName()).doesNotContain("Dark");
};
// assertions succeed:
assertThat(yoda).isInstanceOfSatisfying(Jedi.class, jediRequirements);
assertThat(luke).isInstanceOfSatisfying(Jedi.class, jediRequirements);
// assertions fail:
Jedi vader = new Jedi("Vader", "Red");
assertThat(vader).isInstanceOfSatisfying(Jedi.class, jediRequirements);
// not a Jedi !
assertThat("foo").isInstanceOfSatisfying(Jedi.class, jediRequirements);
isInstanceOfSatisfying
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
T
- the generic type to check the actual value against.type
- the type to check the actual value against.requirements
- the requirements expressed as a Consumer
.public SELF isInstanceOfAny(Class<?>... types)
Example:
// assertions will pass
assertThat("abc").isInstanceOfAny(String.class, Integer.class);
assertThat(new ArrayList<String>()).isInstanceOfAny(LinkedList.class, ArrayList.class);
assertThat(new HashMap<String, Integer>()).isInstanceOfAny(TreeMap.class, Map.class);
// assertions will fail
assertThat(1).isInstanceOfAny(Double.class, Float.class);
assertThat(new ArrayList<String>()).isInstanceOfAny(LinkedList.class, Vector.class);
isInstanceOfAny
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
types
- the types to check the actual value against.public SELF isNotInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat(1).isNotInstanceOf(Double.class);
assertThat(new ArrayList<String>()).isNotInstanceOf(LinkedList.class);
// assertions will fail
assertThat("abc").isNotInstanceOf(String.class);
assertThat(new HashMap<String, Integer>()).isNotInstanceOf(HashMap.class);
assertThat(new HashMap<String, Integer>()).isNotInstanceOf(Map.class);
isNotInstanceOf
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
type
- the type to check the actual value against.public SELF isNotInstanceOfAny(Class<?>... types)
Example:
// assertions will pass
assertThat(1).isNotInstanceOfAny(Double.class, Float.class);
assertThat(new ArrayList<String>()).isNotInstanceOfAny(LinkedList.class, Vector.class);
// assertions will fail
assertThat(1).isNotInstanceOfAny(Double.class, Integer.class);
assertThat(new ArrayList<String>()).isNotInstanceOfAny(LinkedList.class, ArrayList.class);
assertThat(new HashMap<String, Integer>()).isNotInstanceOfAny(TreeMap.class, Map.class);
isNotInstanceOfAny
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
types
- the types to check the actual value against.public SELF hasSameClassAs(Object other)
Example:
// assertions will pass
assertThat(1).hasSameClassAs(2);
assertThat("abc").hasSameClassAs("123");
assertThat(new ArrayList<String>()).hasSameClassAs(new ArrayList<Integer>());
// assertions will fail
assertThat(1).hasSameClassAs("abc");
assertThat(new ArrayList<String>()).hasSameClassAs(new LinkedList<String>());
hasSameClassAs
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
other
- the object to check type against.public SELF hasToString(String expectedToString)
actual.toString()
is equal to the given String
.
Example :
CartoonCaracter homer = new CartoonCaracter("Homer");
// Instead of writing ...
assertThat(homer.toString()).isEqualTo("Homer");
// ... you can simply write:
assertThat(homer).hasToString("Homer");
hasToString
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
expectedToString
- the expected String description of actual.public SELF doesNotHaveSameClassAs(Object other)
Example:
// assertions will pass
assertThat(1).doesNotHaveSameClassAs("abc");
assertThat(new ArrayList<String>()).doesNotHaveSameClassAs(new LinkedList<String>());
// assertions will fail
assertThat(1).doesNotHaveSameClassAs(2);
assertThat("abc").doesNotHaveSameClassAs("123");
assertThat(new ArrayList<String>()).doesNotHaveSameClassAs(new ArrayList<Integer>());
doesNotHaveSameClassAs
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
other
- the object to check type against.public SELF isExactlyInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat("abc").isExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isExactlyInstanceOf(ArrayList.class);
assertThat(new HashMap<String, Integer>()).isExactlyInstanceOf(HashMap.class);
// assertions will fail
assertThat(1).isExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isExactlyInstanceOf(List.class);
assertThat(new HashMap<String, Integer>()).isExactlyInstanceOf(Map.class);
isExactlyInstanceOf
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
type
- the type to check the actual value against.public SELF isNotExactlyInstanceOf(Class<?> type)
Example:
// assertions will pass
assertThat(1).isNotExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isNotExactlyInstanceOf(List.class);
assertThat(new HashMap<String, Integer>()).isNotExactlyInstanceOf(Map.class);
// assertions will fail
assertThat("abc").isNotExactlyInstanceOf(String.class);
assertThat(new ArrayList<String>()).isNotExactlyInstanceOf(ArrayList.class);
assertThat(new HashMap<String, Integer>()).isNotExactlyInstanceOf(HashMap.class);
isNotExactlyInstanceOf
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
type
- the type to check the actual value against.public SELF isOfAnyClassIn(Class<?>... types)
Example:
// assertions will pass
assertThat(new HashMap<String, Integer>()).isOfAnyClassIn(HashMap.class, TreeMap.class);
assertThat(new ArrayList<String>()).isOfAnyClassIn(ArrayList.class, LinkedList.class);
// assertions will fail
assertThat(new HashMap<String, Integer>()).isOfAnyClassIn(TreeMap.class, Map.class);
assertThat(new ArrayList<String>()).isOfAnyClassIn(LinkedList.class, List.class);
isOfAnyClassIn
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
types
- the types to check the actual value against.public SELF isNotOfAnyClassIn(Class<?>... types)
Example:
// assertions will pass
assertThat(new HashMap<String, Integer>()).isNotOfAnyClassIn(Map.class, TreeMap.class);
assertThat(new ArrayList<String>()).isNotOfAnyClassIn(LinkedList.class, List.class);
// assertions will fail
assertThat(new HashMap<String, Integer>()).isNotOfAnyClassIn(HashMap.class, TreeMap.class);
assertThat(new ArrayList<String>()).isNotOfAnyClassIn(ArrayList.class, LinkedList.class);
isNotOfAnyClassIn
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
types
- the types to check the actual value against.public AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> asList()
Example :
Object sortedListAsObject = Arrays.asList(1, 2, 3);
// assertion will pass
assertThat(sortedListAsObject).asList().isSorted();
Object unsortedListAsObject = Arrays.asList(3, 1, 2);
// assertion will fail
assertThat(unsortedListAsObject).asList().isSorted();
public AbstractCharSequenceAssert<?,String> asString()
Example :
Object stringAsObject = "hello world";
// assertion will pass
assertThat(stringAsObject).asString().contains("hello");
// assertion will fail
assertThat(stringAsObject).asString().contains("holla");
public String descriptionText()
describedAs(String, Object...)
or
describedAs(Description)
.public SELF 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...)
.public SELF withFailMessage(String newErrorMessage, Object... args)
overridingErrorMessage(java.lang.String, java.lang.Object...)
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...)
.public SELF usingComparator(Comparator<? super ACTUAL> 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<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
customComparator
- the comparator to use for incoming assertion checks.this
assertion object.public SELF usingDefaultComparator()
This method should be used to disable a custom comparison strategy set by calling
Assert.usingComparator(Comparator)
.
usingDefaultComparator
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
this
assertion object.public SELF withThreadDumpOnError()
System.err
.
Example :
assertThat("Messi").withThreadDumpOnError().isEqualTo("Ronaldo");
will print a thread dump, something similar to this:
"JDWP Command Reader"
java.lang.Thread.State: RUNNABLE
"JDWP Event Helper Thread"
java.lang.Thread.State: RUNNABLE
"JDWP Transport Listener: dt_socket"
java.lang.Thread.State: RUNNABLE
"Signal Dispatcher"
java.lang.Thread.State: RUNNABLE
"Finalizer"
java.lang.Thread.State: WAITING
at java.lang.Object.wait(Native Method)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)
"Reference Handler"
java.lang.Thread.State: WAITING
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:503)
at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
"main"
java.lang.Thread.State: RUNNABLE
at sun.management.ThreadImpl.dumpThreads0(Native Method)
at sun.management.ThreadImpl.dumpAllThreads(ThreadImpl.java:446)
at org.assertj.core.internal.Failures.threadDumpDescription(Failures.java:193)
at org.assertj.core.internal.Failures.printThreadDumpIfNeeded(Failures.java:141)
at org.assertj.core.internal.Failures.failure(Failures.java:91)
at org.assertj.core.internal.Objects.assertEqual(Objects.java:314)
at org.assertj.core.api.AbstractAssert.isEqualTo(AbstractAssert.java:198)
at org.assertj.examples.ThreadDumpOnErrorExample.main(ThreadDumpOnErrorExample.java:28)
withThreadDumpOnError
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
public SELF withRepresentation(Representation representation)
Representation
to describe/represent values in AssertJ error messages.
The usual way to introduce a new Representation
is to extend StandardRepresentation
and override any existing toStringOf
methods that don't suit you. For example you can control
Date
formatting by overriding StandardRepresentation.toStringOf(Date)
).
You can also control other types format by overriding StandardRepresentation.toStringOf(Object)
)
calling your formatting method first and then fall back to the default representation by calling super.toStringOf(Object)
.
Example :
private class Example {}
private class CustomRepresentation extends StandardRepresentation {
// override needed to hook specific formatting
@Override
public String toStringOf(Object o) {
if (o instanceof Example) return "Example";
// fall back to default formatting
return super.toStringOf(o);
}
// change String representation
@Override
protected String toStringOf(String s) {
return "$" + s + "$";
}
}
// next assertion fails with error : "expected:<[null]> but was:<[Example]>"
Example example = new Example();
assertThat(example).withRepresentation(new CustomRepresentation())
.isNull(); // example is not null !
// next assertion fails ...
assertThat("foo").withRepresentation(new CustomRepresentation())
.startsWith("bar");
// ... with error :
Expecting:
<$foo$>
to start with:
<$bar$>
withRepresentation
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
representation
- Describe/represent values in AssertJ error messages.@Deprecated public boolean equals(Object obj)
isEqualTo(java.lang.Object)
insteadequals
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
equals
in class Object
UnsupportedOperationException
- if this method is called.public SELF matches(Predicate<? super ACTUAL> predicate)
Example :
assertThat(player).matches(p -> p.isRookie());
predicate
- the Predicate
to matchthis
assertion object.AssertionError
- if the actual does not match the given Predicate
.NullPointerException
- if given Predicate
is null.public SELF matches(Predicate<? super ACTUAL> predicate, String predicateDescription)
Example :
assertThat(player).matches(p -> p.isRookie(), "is rookie");
The error message contains the predicate description, if the previous assertion fails, it will be:
Expecting:
<player>
to match 'is rookie' predicate.
predicate
- the Predicate
to matchpredicateDescription
- a description of the Predicate
used in the error messagethis
assertion object.AssertionError
- if the actual does not match the given Predicate
.NullPointerException
- if given Predicate
is null.NullPointerException
- if given predicateDescription is null.public SELF satisfies(Consumer<ACTUAL> requirements)
Consumer
.
This is useful to perform a group of assertions on a single object.
Grouping assertions example :
// second constructor parameter is the light saber color
Jedi yoda = new Jedi("Yoda", "Green");
Jedi luke = new Jedi("Luke Skywalker", "Green");
Consumer<Jedi> jediRequirements = jedi -> {
assertThat(jedi.getLightSaberColor()).isEqualTo("Green");
assertThat(jedi.getName()).doesNotContain("Dark");
};
// assertions succeed:
assertThat(yoda).satisfies(jediRequirements);
assertThat(luke).satisfies(jediRequirements);
// assertions fails:
Jedi vader = new Jedi("Vader", "Red");
assertThat(vader).satisfies(jediRequirements);
In the following example, satisfies
prevents the need of define a local variable in order to run multiple assertions:
// no need to define team.getPlayers().get(0).getStats() as a local variable
assertThat(team.getPlayers().get(0).getStats()).satisfies(stats -> {
assertThat(stats.pointPerGame).isGreaterThan(25.7);
assertThat(stats.assistsPerGame).isGreaterThan(7.2);
assertThat(stats.reboundsPerGame).isBetween(9, 12);
};
requirements
- to assert on the actual object - must not be null.NullPointerException
- if given Consumer is nullpublic static void setCustomRepresentation(Representation customRepresentation)
public SELF hasSameHashCodeAs(Object other)
Example:
// assertions will pass
assertThat(42L).hasSameHashCodeAs(42L);
assertThat("The Force").hasSameHashCodeAs("The Force");
assertThat(new Jedi("Yoda", "Blue")).hasSameHashCodeAs(new Jedi("Yoda", "Blue"));
// assertions will fail
assertThat(42L).hasSameHashCodeAs(2501L);
assertThat(null).hasSameHashCodeAs("The Force");
assertThat("The Force").hasSameHashCodeAs(null);
hasSameHashCodeAs
in interface Assert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
other
- the object to check hashCode against.protected <E> AbstractListAssert<?,List<? extends E>,E,ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual)
AbstractListAssert
.
Implementations need to redefine either to be proxy friendly (i.e. no final assertion methods like ProxyableListAssert
)
or generic vararg friendly (to use SafeVarargs
annotation which requires final method)like ListAssert
.
The default implementation will assume that this concrete implementation is NOT a soft assertion.
E
- the type of elements.newActual
- new valueAbstractListAssert
.Copyright © 2014–2018 AssertJ. All rights reserved.