Class AbstractAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- java.lang.Object
-
- org.assertj.core.api.AbstractAssert<SELF,ACTUAL>
-
- Type Parameters:
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.
- All Implemented Interfaces:
Assert<SELF,ACTUAL>
,Descriptable<SELF>
,ExtensionPoints<SELF,ACTUAL>
- Direct Known Subclasses:
AbstractBooleanAssert
,AbstractCharSequenceAssert
,AbstractClassAssert
,AbstractCompletableFutureAssert
,AbstractDateAssert
,AbstractEnumerableAssert
,AbstractFileAssert
,AbstractFutureAssert
,AbstractInputStreamAssert
,AbstractIterableAssert
,AbstractIteratorAssert
,AbstractObjectArrayAssert
,AbstractObjectAssert
,AbstractOptionalAssert
,AbstractOptionalDoubleAssert
,AbstractOptionalIntAssert
,AbstractOptionalLongAssert
,AbstractPredicateAssert
,AbstractPredicateLikeAssert
,AbstractTemporalAssert
,AbstractUriAssert
,AbstractUrlAssert
,AtomicBooleanAssert
,AtomicIntegerAssert
,AtomicLongAssert
,AtomicReferenceArrayAssert
,AtomicReferenceAssert
,RecursiveComparisonAssert
,ThrowableAssertAlternative
public abstract class AbstractAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL> extends Object implements Assert<SELF,ACTUAL>
Base class for all assertions.- Author:
- Alex Ruiz, Joel Costigliola, Mikhail Mazursky, Nicolas François
-
-
Field Summary
Fields Modifier and Type Field Description protected ACTUAL
actual
(package private) AssertionErrorCreator
assertionErrorCreator
(package private) Conditions
conditions
private static Representation
customRepresentation
WritableAssertionInfo
info
protected SELF
myself
(package private) Objects
objects
private static String
ORG_ASSERTJ
static boolean
throwUnsupportedExceptionOnEquals
-
Constructor Summary
Constructors Constructor Description AbstractAssert(ACTUAL actual, Class<?> selfType)
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods Modifier and Type Method Description SELF
as(String description, Object... args)
Sets the description of the assertion that is going to be called after.SELF
as(Description description)
Sets the description of the assertion that is going to be called after.<ASSERT extends AbstractAssert<?,?>>
ASSERTasInstanceOf(InstanceOfAssertFactory<?,ASSERT> instanceOfAssertFactory)
Uses anInstanceOfAssertFactory
to verify that the actual value is an instance of a given type and to produce a newAssert
narrowed to that type.AbstractListAssert<?,List<?>,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.AbstractStringAssert<?>
asString()
Returns a String assertion for thetoString()
of the actual value, to allow chaining of String-specific assertions from this call.private AssertionError
catchAssertionError(Consumer assertions)
SELF
describedAs(String description, Object... args)
Sets the description of the assertion that is going to be called after.SELF
describedAs(Description description)
Sets the description of the assertion that is going to be called after.String
descriptionText()
The description of this assertion set withdescribedAs(String, Object...)
ordescribedAs(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.useisEqualTo(java.lang.Object)
insteadprotected void
failWithMessage(String errorMessage, Object... arguments)
Utility method to ease writing custom assertions classes usingString.format(String, Object...)
specifiers in error message.WritableAssertionInfo
getWritableAssertionInfo()
Exposes theWritableAssertionInfo
used in the current assertion for better extensibility.
When writing your own assertion class, you can use the returnedWritableAssertionInfo
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 actualactual.toString()
is equal to the givenString
.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.private boolean
isAssertjAssertClass()
private boolean
isElementOfCustomAssert(StackTraceElement stackTraceElement)
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 aConsumer
.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 notnull
.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 isnull
.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.private SELF
matches(Predicate<? super ACTUAL> predicate, PredicateDescription predicateDescription)
private AssertionError
multipleAssertionsError(List<AssertionError> assertionErrors)
protected <E> AbstractListAssert<?,List<? extends E>,E,ObjectAssert<E>>
newListAssertInstance(List<? extends E> newActual)
Create aAbstractListAssert
.SELF
overridingErrorMessage(String newErrorMessage, Object... args)
Overrides AssertJ default error message by the given one.private void
propagateAssertionInfoFrom(AbstractAssert<?,?> assertInstance)
private void
removeCustomAssertRelatedElementsFromStackTraceIfNeeded(AssertionError assertionError)
SELF
satisfies(Consumer<ACTUAL> requirements)
Verifies that the actual object satisfied the given requirements expressed as aConsumer
.SELF
satisfies(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition.SELF
satisfiesAnyOf(Consumer<ACTUAL> assertions1, Consumer<ACTUAL> assertions2)
Verifies that the actual object under test satisfies at least one of the given assertions group expressed asConsumer
s.SELF
satisfiesAnyOf(Consumer<ACTUAL> assertions1, Consumer<ACTUAL> assertions2, Consumer<ACTUAL> assertions3)
Verifies that the actual object under test satisfies at least one of the given assertions group expressed asConsumer
s.private SELF
satisfiesAnyOfAssertionsGroups(Consumer<ACTUAL>... assertionsGroups)
private boolean
satisfiesAssertions(Consumer assertions)
static void
setCustomRepresentation(Representation customRepresentation)
protected void
throwAssertionError(ErrorMessageFactory errorMessageFactory)
Utility method to throw anAssertionError
given aBasicErrorMessageFactory
.SELF
usingComparator(Comparator<? super ACTUAL> customComparator)
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.SELF
usingComparator(Comparator<? super ACTUAL> customComparator, String customComparatorDescription)
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.SELF
usingDefaultComparator()
Revert to standard comparison for the incoming assertion checks.(package private) SELF
withAssertionState(AbstractAssert assertInstance)
SELF
withFailMessage(String newErrorMessage, Object... args)
Alternative method foroverridingErrorMessage(java.lang.String, java.lang.Object...)
SELF
withRepresentation(Representation representation)
Use the givenRepresentation
to describe/represent values in AssertJ error messages.SELF
withThreadDumpOnError()
In case of an assertion error, a thread dump will be printed toSystem.err
.
-
-
-
Field Detail
-
throwUnsupportedExceptionOnEquals
public static boolean throwUnsupportedExceptionOnEquals
-
ORG_ASSERTJ
private static final String ORG_ASSERTJ
- See Also:
- Constant Field Values
-
objects
Objects objects
-
conditions
Conditions conditions
-
info
public WritableAssertionInfo info
-
actual
protected final ACTUAL actual
-
myself
protected final SELF extends AbstractAssert<SELF,ACTUAL> myself
-
customRepresentation
private static Representation customRepresentation
-
assertionErrorCreator
AssertionErrorCreator assertionErrorCreator
-
-
Method Detail
-
getWritableAssertionInfo
public WritableAssertionInfo getWritableAssertionInfo()
Exposes theWritableAssertionInfo
used in the current assertion for better extensibility.
When writing your own assertion class, you can use the returnedWritableAssertionInfo
to change the error message and still keep the description set by the assertion user.- Returns:
- the
WritableAssertionInfo
used in the current assertion
-
failWithMessage
protected void failWithMessage(String errorMessage, Object... arguments)
Utility method to ease writing custom assertions classes usingString.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 withoverridingErrorMessage(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; }
- Parameters:
errorMessage
- the error message to formatarguments
- the arguments referenced by the format specifiers in the errorMessage string.
-
throwAssertionError
protected void throwAssertionError(ErrorMessageFactory errorMessageFactory)
Utility method to throw anAssertionError
given aBasicErrorMessageFactory
.Instead of writing ...
... you can simply write :throw Failures.instance().failure(info, ShouldBePresent.shouldBePresent());
throwAssertionError(info, ShouldBePresent.shouldBePresent());
- Parameters:
errorMessageFactory
- used to define the error message.- Throws:
AssertionError
- with a message corresponding to the givenBasicErrorMessageFactory
.
-
removeCustomAssertRelatedElementsFromStackTraceIfNeeded
private void removeCustomAssertRelatedElementsFromStackTraceIfNeeded(AssertionError assertionError)
-
isAssertjAssertClass
private boolean isAssertjAssertClass()
-
isElementOfCustomAssert
private boolean isElementOfCustomAssert(StackTraceElement stackTraceElement)
-
as
public SELF as(String description, Object... args)
Sets the description of the assertion that is going to be called after.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]>"); }
- Specified by:
as
in interfaceDescriptable<SELF extends AbstractAssert<SELF,ACTUAL>>
- Parameters:
description
- the new description to set.args
- optional parameter if description is a format String.- Returns:
this
object.- See Also:
Descriptable.describedAs(String, Object...)
-
as
public SELF as(Description description)
Sets the description of the assertion that is going to be called after.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.- Specified by:
as
in interfaceDescriptable<SELF extends AbstractAssert<SELF,ACTUAL>>
- Parameters:
description
- the new description to set.- Returns:
this
object.- See Also:
Descriptable.describedAs(Description)
-
inHexadecimal
protected SELF inHexadecimal()
Use hexadecimal object representation instead of standard representation in error messages.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:
With Hexadecimal message:assertThat("µµµ").contains("μμμ"); java.lang.AssertionError: Expecting: <"µµµ"> to contain: <"μμμ">
assertThat("µµµ").inHexadecimal().contains("μμμ"); java.lang.AssertionError: Expecting: <"['00B5', '00B5', '00B5']"> to contain: <"['03BC', '03BC', '03BC']">
- Returns:
this
assertion object.
-
inBinary
protected SELF inBinary()
Use binary object representation instead of standard representation in error messages.Example:
assertThat(1).inBinary().isEqualTo(2); org.junit.ComparisonFailure: Expected :0b00000000_00000000_00000000_00000010 Actual :0b00000000_00000000_00000000_00000001
- Returns:
this
assertion object.
-
describedAs
public SELF describedAs(String description, Object... args)
Sets the description of the assertion that is going to be called after.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...)
- Specified by:
describedAs
in interfaceDescriptable<SELF extends AbstractAssert<SELF,ACTUAL>>
- Parameters:
description
- the new description to set.args
- optional parameter if description is a format String.- Returns:
this
object.
-
describedAs
public SELF describedAs(Description description)
Sets the description of the assertion that is going to be called after.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.- Specified by:
describedAs
in interfaceDescriptable<SELF extends AbstractAssert<SELF,ACTUAL>>
- Parameters:
description
- the new description to set.- Returns:
this
object.
-
isEqualTo
public SELF isEqualTo(Object expected)
Verifies that the actual value is equal to the given one.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);
-
isNotEqualTo
public SELF isNotEqualTo(Object other)
Verifies that the actual value is not equal to the given one.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>());
- Specified by:
isNotEqualTo
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
other
- the given value to compare the actual value to.- Returns:
this
assertion object.
-
isNull
public void isNull()
Verifies that the actual value isnull
.Example:
String value = null; // assertion will pass assertThat(value).isNull(); // assertions will fail assertThat("abc").isNull(); assertThat(new HashMap<String, Integer>()).isNull();
-
isNotNull
public SELF isNotNull()
Verifies that the actual value is notnull
.Example:
// assertion will pass assertThat("abc").isNotNull(); assertThat(new HashMap<String, Integer>()).isNotNull(); // assertion will fail String value = null; assertThat(value).isNotNull();
-
isSameAs
public SELF isSameAs(Object expected)
Verifies that the actual value is the same as the given one, ie using == comparison.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);
-
isNotSameAs
public SELF isNotSameAs(Object other)
Verifies that the actual value is not the same as the given one, ie using == comparison.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);
- Specified by:
isNotSameAs
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
other
- the given value to compare the actual value to.- Returns:
this
assertion object.
-
isIn
public SELF isIn(Object... values)
Verifies that the actual value is present in the given array of values.Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya }; // assertion will pass: assertThat(nenya).isIn(elvesRings); // assertion will fail: assertThat(oneRing).isIn(elvesRings);
-
isNotIn
public SELF isNotIn(Object... values)
Verifies that the actual value is not present in the given array of values.Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya }; // assertion will pass: assertThat(oneRing).isNotIn(elvesRings); // assertion will fail: assertThat(nenya).isNotIn(elvesRings);
-
isIn
public SELF isIn(Iterable<?> values)
Verifies that the actual value is present in the given values.Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertion will pass: assertThat(nenya).isIn(elvesRings); // assertion will fail: assertThat(oneRing).isIn(elvesRings);
-
isNotIn
public SELF isNotIn(Iterable<?> values)
Verifies that the actual value is not present in the given values.Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertion will pass: assertThat(oneRing).isNotIn(elvesRings); // assertion will fail: assertThat(nenya).isNotIn(elvesRings);
-
is
public SELF is(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition. This method is an alias for
.ExtensionPoints.has(Condition)
- Specified by:
is
in interfaceExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
condition
- the given condition.- Returns:
this ExtensionPoints
object.- See Also:
ExtensionPoints.has(Condition)
-
isNot
public SELF isNot(Condition<? super ACTUAL> 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 interfaceExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
condition
- the given condition.- Returns:
this ExtensionPoints
object.- See Also:
ExtensionPoints.isNot(Condition)
-
has
public SELF has(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition. This method is an alias for
.ExtensionPoints.is(Condition)
- Specified by:
has
in interfaceExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
condition
- the given condition.- Returns:
this ExtensionPoints
object.- See Also:
ExtensionPoints.is(Condition)
-
doesNotHave
public SELF doesNotHave(Condition<? super ACTUAL> 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 interfaceExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
condition
- the given condition.- Returns:
this ExtensionPoints
object.- See Also:
ExtensionPoints.isNot(Condition)
-
satisfies
public SELF satisfies(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition. This method is an alias for
.ExtensionPoints.is(Condition)
Example:
// Given Condition<String> fairyTale = new Condition<>(s -> s.startsWith("Once upon a time"), "fairy tale start"); // When String littleRedCap = "Once upon a time there was a dear little girl ..."; // Then assertThat(littleRedCap).satisfies(fairyTale);
- Specified by:
satisfies
in interfaceExtensionPoints<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
condition
- the given condition.- Returns:
this ExtensionPoints
object.- See Also:
ExtensionPoints.is(Condition)
-
asInstanceOf
public <ASSERT extends AbstractAssert<?,?>> ASSERT asInstanceOf(InstanceOfAssertFactory<?,ASSERT> instanceOfAssertFactory)
Uses anInstanceOfAssertFactory
to verify that the actual value is an instance of a given type and to produce a newAssert
narrowed to that type.InstanceOfAssertFactories
provides static factories for all the types supported byAssertions#assertThat
.Additional factories can be created with custom
InstanceOfAssertFactory
instances.Example:
// assertions will pass Object string = "abc"; assertThat(string).asInstanceOf(InstanceOfAssertFactories.STRING).startsWith("ab"); Object integer = 1; assertThat(integer).asInstanceOf(InstanceOfAssertFactories.INTEGER).isNotZero(); // assertion will fail assertThat("abc").asInstanceOf(InstanceOfAssertFactories.INTEGER);
- Specified by:
asInstanceOf
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Type Parameters:
ASSERT
- the type of the resultingAssert
.- Parameters:
instanceOfAssertFactory
- the factory which verifies the type and creates the newAssert
.- Returns:
- the narrowed
Assert
instance. - See Also:
InstanceOfAssertFactory
,InstanceOfAssertFactories
-
isInstanceOf
public SELF isInstanceOf(Class<?> type)
Verifies that the actual value is an instance of the given 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);
- Specified by:
isInstanceOf
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
-
isInstanceOfSatisfying
public <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 aConsumer
.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);
- Specified by:
isInstanceOfSatisfying
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Type Parameters:
T
- the generic type to check the actual value against.- Parameters:
type
- the type to check the actual value against.requirements
- the requirements expressed as aConsumer
.- Returns:
- this assertion object.
-
isInstanceOfAny
public SELF isInstanceOfAny(Class<?>... types)
Verifies that the actual value is an instance of any of the given 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);
- Specified by:
isInstanceOfAny
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
-
isNotInstanceOf
public SELF isNotInstanceOf(Class<?> type)
Verifies that the actual value is not an instance of the given 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);
- Specified by:
isNotInstanceOf
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
-
isNotInstanceOfAny
public SELF isNotInstanceOfAny(Class<?>... types)
Verifies that the actual value is not an instance of any of the given 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);
- Specified by:
isNotInstanceOfAny
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
-
hasSameClassAs
public SELF hasSameClassAs(Object other)
Verifies that the actual value has the same class as the given object.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>());
- Specified by:
hasSameClassAs
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
other
- the object to check type against.- Returns:
- this assertion object.
-
hasToString
public SELF hasToString(String expectedToString)
Verifies that actualactual.toString()
is equal to the givenString
.Example :
CartoonCharacter homer = new CartoonCharacter("Homer"); // Instead of writing ... assertThat(homer.toString()).isEqualTo("Homer"); // ... you can simply write: assertThat(homer).hasToString("Homer");
- Specified by:
hasToString
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
expectedToString
- the expected String description of actual.- Returns:
- this assertion object.
-
doesNotHaveSameClassAs
public SELF doesNotHaveSameClassAs(Object other)
Verifies that the actual value does not have the same class as the given object.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>());
- Specified by:
doesNotHaveSameClassAs
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
other
- the object to check type against.- Returns:
- this assertion object.
-
isExactlyInstanceOf
public SELF isExactlyInstanceOf(Class<?> type)
Verifies that the actual value is exactly an instance of the given 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);
- Specified by:
isExactlyInstanceOf
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
-
isNotExactlyInstanceOf
public SELF isNotExactlyInstanceOf(Class<?> type)
Verifies that the actual value is not exactly an instance of given 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);
- Specified by:
isNotExactlyInstanceOf
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
-
isOfAnyClassIn
public SELF isOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is in given 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);
- Specified by:
isOfAnyClassIn
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
-
isNotOfAnyClassIn
public SELF isNotOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is not in given 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);
- Specified by:
isNotOfAnyClassIn
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
-
asList
public AbstractListAssert<?,List<?>,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.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();
-
asString
public AbstractStringAssert<?> asString()
Returns a String assertion for thetoString()
of the actual value, to allow chaining of String-specific assertions from this call.Example :
Object stringAsObject = "hello world"; // assertion will pass assertThat(stringAsObject).asString().contains("hello"); // assertion will fail assertThat(stringAsObject).asString().contains("holla");
-
descriptionText
public String descriptionText()
The description of this assertion set withdescribedAs(String, Object...)
ordescribedAs(Description)
.- Returns:
- the description String representation of this assertion.
-
overridingErrorMessage
public SELF overridingErrorMessage(String newErrorMessage, Object... args)
Overrides AssertJ default error message by the given one.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 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();
- Parameters:
newErrorMessage
- the error message that will replace the default one provided by Assertj.args
- the args used to fill error message as inString.format(String, Object...)
.- Returns:
- this assertion object.
-
withFailMessage
public SELF withFailMessage(String newErrorMessage, Object... args)
Alternative method foroverridingErrorMessage(java.lang.String, java.lang.Object...)
You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
Example:
assertThat(player.isRookie()).withFailMessage("Expecting Player <%s> to be a rookie but was not.", player) .isTrue();
- Parameters:
newErrorMessage
- the error message that will replace the default one provided by Assertj.args
- the args used to fill error message as inString.format(String, Object...)
.- Returns:
- this assertion object.
-
usingComparator
public SELF usingComparator(Comparator<? super ACTUAL> customComparator)
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.
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 interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
customComparator
- the comparator to use for the incoming assertion checks.- Returns:
this
assertion object.
-
usingComparator
public SELF usingComparator(Comparator<? super ACTUAL> customComparator, String customComparatorDescription)
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.
Examples :
// frodo and sam are instances of Character with Hobbit race (obviously :). // raceComparator implements Comparator<Character> assertThat(frodo).usingComparator(raceComparator, "Hobbit Race Comparator").isEqualTo(sam);
- Specified by:
usingComparator
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
customComparator
- the comparator to use for the incoming assertion checks.customComparatorDescription
- comparator description to be used in assertion error messages- Returns:
this
assertion object.
-
usingDefaultComparator
public SELF usingDefaultComparator()
Revert to standard comparison for the incoming assertion checks.This method should be used to disable a custom comparison strategy set by calling
usingComparator
.- Specified by:
usingDefaultComparator
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Returns:
this
assertion object.
-
withThreadDumpOnError
public SELF withThreadDumpOnError()
In case of an assertion error, a thread dump will be printed toSystem.err
.Example :
will print a thread dump, something similar to this:assertThat("Messi").withThreadDumpOnError().isEqualTo("Ronaldo");
"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)
- Specified by:
withThreadDumpOnError
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Returns:
- this assertion object.
-
withRepresentation
public SELF withRepresentation(Representation representation)
Use the givenRepresentation
to describe/represent values in AssertJ error messages.The usual way to introduce a new
Representation
is to extendStandardRepresentation
and override any existingtoStringOf
methods that don't suit you. For example you can controlDate
formatting by overridingStandardRepresentation.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 callingsuper.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$>
- Specified by:
withRepresentation
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
representation
- Describe/represent values in AssertJ error messages.- Returns:
- this assertion object.
-
equals
@Deprecated public boolean equals(Object obj)
Deprecated.useisEqualTo(java.lang.Object)
instead- Specified by:
equals
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Overrides:
equals
in classObject
- Throws:
UnsupportedOperationException
- if this method is called.
-
matches
public SELF matches(Predicate<? super ACTUAL> predicate)
Verifies that the actual object matches the given predicate.Example :
assertThat(player).matches(p -> p.isRookie());
- Parameters:
predicate
- thePredicate
to match- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual does not match the givenPredicate
.NullPointerException
- if givenPredicate
is null.
-
matches
public 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.Example :
The error message contains the predicate description, if the previous assertion fails, it will be:assertThat(player).matches(p -> p.isRookie(), "is rookie");
Expecting: <player> to match 'is rookie' predicate.
- Parameters:
predicate
- thePredicate
to matchpredicateDescription
- a description of thePredicate
used in the error message- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual does not match the givenPredicate
.NullPointerException
- if givenPredicate
is null.NullPointerException
- if given predicateDescription is null.
-
satisfies
public SELF satisfies(Consumer<ACTUAL> requirements)
Verifies that the actual object satisfied the given requirements expressed as aConsumer
.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); };
- Parameters:
requirements
- to assert on the actual object - must not be null.- Returns:
- this assertion object.
- Throws:
NullPointerException
- if given Consumer is null
-
satisfiesAnyOf
public SELF satisfiesAnyOf(Consumer<ACTUAL> assertions1, Consumer<ACTUAL> assertions2)
Verifies that the actual object under test satisfies at least one of the given assertions group expressed asConsumer
s.This allows users to perform OR like assertions since only one the assertions group has to be met.
Overriding error message
is not supported as it would prevent from getting the error messages of the failing assertions, these are valuable to figure out what went wrong.
Describing the assertion is supported (for example withas(String, Object...)
).Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", HOBBIT); Consumer<TolkienCharacter> isHobbit = tolkienCharacter -> assertThat(tolkienCharacter.getRace()).isEqualTo(HOBBIT); Consumer<TolkienCharacter> isElf = tolkienCharacter -> assertThat(tolkienCharacter.getRace()).isEqualTo(ELF); // assertion succeeds: assertThat(frodo).satisfiesAnyOf(isElf, isHobbit); // assertion fails: TolkienCharacter boromir = new TolkienCharacter("Boromir", MAN); assertThat(boromir).satisfiesAnyOf(isHobbit, isElf);
- Parameters:
assertions1
- the first group of assertions to run against the object under test - must not be null.assertions2
- the second group of assertions to run against the object under test - must not be null.- Returns:
- this assertion object.
- Throws:
IllegalArgumentException
- if any given assertions group is null- Since:
- 3.12.0
-
satisfiesAnyOf
public SELF satisfiesAnyOf(Consumer<ACTUAL> assertions1, Consumer<ACTUAL> assertions2, Consumer<ACTUAL> assertions3)
Verifies that the actual object under test satisfies at least one of the given assertions group expressed asConsumer
s.This allows users to perform OR like assertions since only one the assertions group has to be met.
Overriding error message
is not supported as it would prevent from getting the error messages of the failing assertions, these are valuable to figure out what went wrong.
Describing the assertion is supported (for example withas(String, Object...)
).Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", HOBBIT); Consumer<TolkienCharacter> isHobbit = tolkienCharacter -> assertThat(tolkienCharacter.getRace()).isEqualTo(HOBBIT); Consumer<TolkienCharacter> isElf = tolkienCharacter -> assertThat(tolkienCharacter.getRace()).isEqualTo(ELF); Consumer<TolkienCharacter> isOrc = tolkienCharacter -> assertThat(tolkienCharacter.getRace()).isEqualTo(ORC); // assertion succeeds: assertThat(frodo).satisfiesAnyOf(isElf, isHobbit, isOrc); // assertion fails: TolkienCharacter boromir = new TolkienCharacter("Boromir", MAN); assertThat(boromir).satisfiesAnyOf(isHobbit, isElf, isOrc);
- Parameters:
assertions1
- the first group of assertions to run against the object under test - must not be null.assertions2
- the second group of assertions to run against the object under test - must not be null.assertions3
- the third group of assertions to run against the object under test - must not be null.- Returns:
- this assertion object.
- Throws:
IllegalArgumentException
- if any given assertions group is null- Since:
- 3.12.0
-
satisfiesAnyOfAssertionsGroups
@SafeVarargs private final SELF satisfiesAnyOfAssertionsGroups(Consumer<ACTUAL>... assertionsGroups) throws AssertionError
- Throws:
AssertionError
-
multipleAssertionsError
private AssertionError multipleAssertionsError(List<AssertionError> assertionErrors)
-
satisfiesAssertions
private boolean satisfiesAssertions(Consumer assertions)
-
catchAssertionError
private AssertionError catchAssertionError(Consumer assertions)
-
matches
private SELF matches(Predicate<? super ACTUAL> predicate, PredicateDescription predicateDescription)
-
setCustomRepresentation
public static void setCustomRepresentation(Representation customRepresentation)
-
hasSameHashCodeAs
public SELF hasSameHashCodeAs(Object other)
Verifies that the actual object has the same hashCode as the given object.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);
- Specified by:
hasSameHashCodeAs
in interfaceAssert<SELF extends AbstractAssert<SELF,ACTUAL>,ACTUAL>
- Parameters:
other
- the object to check hashCode against.- Returns:
- this assertion object.
-
newListAssertInstance
protected <E> AbstractListAssert<?,List<? extends E>,E,ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual)
Create aAbstractListAssert
.Implementations need to redefine either to be proxy friendly (i.e. no final assertion methods like
ProxyableListAssert
) or generic vararg friendly (to useSafeVarargs
annotation which requires final method)likeListAssert
.The default implementation will assume that this concrete implementation is NOT a soft assertion.
- Type Parameters:
E
- the type of elements.- Parameters:
newActual
- new value- Returns:
- a new
AbstractListAssert
.
-
withAssertionState
SELF withAssertionState(AbstractAssert assertInstance)
-
propagateAssertionInfoFrom
private void propagateAssertionInfoFrom(AbstractAssert<?,?> assertInstance)
-
-