Class AbstractAssert<SELF extends AbstractAssert<SELF,ACTUAL>,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:
Abstract2DArrayAssert
,AbstractBooleanAssert
,AbstractCharSequenceAssert
,AbstractClassAssert
,AbstractCompletableFutureAssert
,AbstractDateAssert
,AbstractEnumerableAssert
,AbstractFileAssert
,AbstractFutureAssert
,AbstractInputStreamAssert
,AbstractIterableAssert
,AbstractIteratorAssert
,AbstractLongAdderAssert
,AbstractMatcherAssert
,AbstractObjectArrayAssert
,AbstractObjectAssert
,AbstractOptionalAssert
,AbstractOptionalDoubleAssert
,AbstractOptionalIntAssert
,AbstractOptionalLongAssert
,AbstractPeriodAssert
,AbstractPredicateAssert
,AbstractSpliteratorAssert
,AbstractTemporalAssert
,AbstractUrlAssert
,AtomicBooleanAssert
,AtomicIntegerAssert
,AtomicLongAssert
,AtomicReferenceArrayAssert
,AtomicReferenceAssert
,DoublePredicateAssert
,IntPredicateAssert
,LongPredicateAssert
,RecursiveComparisonAssert
- Author:
- Alex Ruiz, Joel Costigliola, Mikhail Mazursky, Nicolas François
-
Field Summary
-
Constructor Summary
-
Method Summary
Modifier and TypeMethodDescriptionprotected boolean
Deprecated.<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.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.protected AssertionError
assertionError
(ErrorMessageFactory errorMessageFactory) asString()
Returns a String assertion for thetoString()
of the actual value, to allow chaining of String-specific assertions from this call.describedAs
(Description description) Sets the description of the assertion that is going to be called after.The description of this assertion set withDescriptable.describedAs(String, Object...)
ordescribedAs(Description)
.doesNotHave
(Condition<? super ACTUAL> condition) Verifies that the actual value does not satisfy the given condition.doesNotHaveSameClassAs
(Object other) Verifies that the actual value does not have the same class as the given object.doesNotHaveSameHashCodeAs
(Object other) Verifies that the actual object does not have the same hashCode as the given object.doesNotHaveToString
(String otherToString) Verifies that actualactual.toString()
is not equal to the givenString
.boolean
Deprecated.useisEqualTo(java.lang.Object)
insteadprotected <ASSERT extends AbstractAssert<?,
?>>
ASSERTextracting
(String propertyOrField, AssertFactory<Object, ASSERT> assertFactory) Extracts the value of given field/property from the object under test and creates a new assertion object using the given assert factory.protected <T,
ASSERT extends AbstractAssert<?, ?>>
ASSERTextracting
(Function<? super ACTUAL, ? extends T> extractor, AssertFactory<T, ASSERT> assertFactory) Uses the givenFunction
to extract a value from the object under test and creates a new assertion object using the given assert factory.protected AssertionError
Generate a custom assertion error using the information in this assertion.protected AssertionError
failureWithActualExpected
(Object actual, Object expected, String errorMessageFormat, Object... arguments) Generate a custom assertion error using the information in this assertion, using the given actual and expected values.protected void
failWithActualExpectedAndMessage
(Object actual, Object expected, String errorMessageFormat, Object... arguments) Throw an assertion error based on information in this assertion.protected void
failWithMessage
(String errorMessage, Object... arguments) Throw an assertion error based on information in this assertion.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.Verifies that the actual value satisfies the given condition.int
hashCode()
Always returns 1.hasSameClassAs
(Object other) Verifies that the actual value has the same class as the given object.hasSameHashCodeAs
(Object other) Verifies that the actual object has the same hashCode as the given object.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
Use hexadecimal object representation instead of standard representation in error messages.Verifies that the actual value satisfies the given condition.protected boolean
isElementOfCustomAssert
(StackTraceElement stackTraceElement) Verifies that the actual value is equal to the given one.isExactlyInstanceOf
(Class<?> type) Verifies that the actual value is exactly an instance of the given type.Verifies that the actual value is present in the given iterable.Verifies that the actual value is present in the given array of values.isInstanceOf
(Class<?> type) Verifies that the actual value is an instance of the given type.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
.Verifies that the actual value does not satisfy the given condition.isNotEqualTo
(Object other) Verifies that the actual value is not equal to the given one.isNotExactlyInstanceOf
(Class<?> type) Verifies that the actual value is not exactly an instance of given type.Verifies that the actual value is not present in the given iterable.Verifies that the actual value is not present in the given array of values.isNotInstanceOf
(Class<?> type) Verifies that the actual value is not an instance of the given type.isNotInstanceOfAny
(Class<?>... types) Verifies that the actual value is not an instance of any of the given types.Verifies that the actual value is notnull
.isNotOfAnyClassIn
(Class<?>... types) Verifies that the actual value type is not in given types.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
.isOfAnyClassIn
(Class<?>... types) Verifies that the actual value type is in given types.Verifies that the actual value is the same as the given one, ie using == comparison.Verifies that the actual object matches the given predicate.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 aAbstractListAssert
from the given list.overridingErrorMessage
(String newErrorMessage, Object... args) Overrides AssertJ default error message by the given one.overridingErrorMessage
(Supplier<String> supplier) Overrides AssertJ default error message by the given one.final SELF
Verifies that the actual object satisfied the given requirements expressed asConsumer
s.Verifies that the actual value satisfies the given condition.final SELF
satisfies
(ThrowingConsumer<? super ACTUAL>... assertions) Verifies that the actual object satisfied the given requirements expressed asThrowingConsumer
s.final SELF
satisfiesAnyOf
(Consumer<? super ACTUAL>... assertions) Verifies that the actual object under test satisfies at least one of the given assertions group expressed asConsumer
s.final SELF
satisfiesAnyOf
(ThrowingConsumer<? super ACTUAL>... assertions) Verifies that the actual object under test satisfies at least one of the given assertions group expressed asThrowingConsumer
s.protected SELF
satisfiesAnyOfForProxy
(Consumer<? super ACTUAL>[] assertionsGroups) protected SELF
satisfiesForProxy
(Consumer<? super ACTUAL>[] assertionsGroups) static void
setCustomRepresentation
(Representation customRepresentation) static void
setDescriptionConsumer
(Consumer<Description> descriptionConsumer) static void
setPrintAssertionsDescription
(boolean printAssertionsDescription) protected void
throwAssertionError
(ErrorMessageFactory errorMessageFactory) Utility method to throw anAssertionError
given aBasicErrorMessageFactory
.usingComparator
(Comparator<? super ACTUAL> customComparator) Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.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.Revert to standard comparison for the incoming assertion checks.protected RecursiveComparisonAssert<?>
protected RecursiveComparisonAssert<?>
usingRecursiveComparison
(RecursiveComparisonConfiguration recursiveComparisonConfiguration) withFailMessage
(String newErrorMessage, Object... args) Alternative method foroverridingErrorMessage(java.lang.String, java.lang.Object...)
withFailMessage
(Supplier<String> supplier) Alternative method foroverridingErrorMessage(java.lang.String, java.lang.Object...)
withRepresentation
(Representation representation) Use the givenRepresentation
to describe/represent values in AssertJ error messages.In case of an assertion error, a thread dump will be printed toSystem.err
.Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
Methods inherited from interface org.assertj.core.api.Descriptable
as, as, as, describedAs
-
Field Details
-
throwUnsupportedExceptionOnEquals
public static boolean throwUnsupportedExceptionOnEquals -
objects
protected org.assertj.core.internal.Objects objects -
info
-
actual
-
myself
-
-
Constructor Details
-
AbstractAssert
-
-
Method Details
-
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
Throw an assertion error based on information in this assertion. Equivalent to:throw failure(errorMessage, arguments);
This method is a thin wrapper around
failure()
- see that method for a more detailed description.Note that generally speaking, using
failure()
directly is preferable to using this wrapper method, as the compiler and other code analysis tools will be able to tell that the statement will never return normally and respond appropriately.- Parameters:
errorMessage
- the error message to formatarguments
- the arguments referenced by the format specifiers in the errorMessage string.- See Also:
-
failure
Generate a custom assertion error using the information in this assertion.This is a utility method to ease writing custom assertions classes using
String.format(String, Object...)
specifiers in error message.Moreover, this method honors any description set with
Descriptable.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.- Returns:
- The generated assertion error.
- See Also:
-
failWithActualExpectedAndMessage
protected void failWithActualExpectedAndMessage(Object actual, Object expected, String errorMessageFormat, Object... arguments) Throw an assertion error based on information in this assertion. Equivalent to:throw failureWithActualExpected(actual, expected, errorMessageFormat, arguments);
This method is a thin wrapper around
failureWithActualExpected()
- see that method for a more detailed description. Note that generally speaking, usingfailureWithActualExpected()
directly is preferable to using this wrapper method, as the compiler and other code analysis tools will be able to tell that the statement will never return normally and respond appropriately.- Parameters:
actual
- the actual object that was found during the testexpected
- the object that was expectederrorMessageFormat
- the error message to formatarguments
- the arguments referenced by the format specifiers in the errorMessage string.- See Also:
-
failureWithActualExpected
protected AssertionError failureWithActualExpected(Object actual, Object expected, String errorMessageFormat, Object... arguments) Generate a custom assertion error using the information in this assertion, using the given actual and expected values.This is a utility method to ease writing custom assertions classes using
String.format(String, Object...)
specifiers in error message with actual and expected values.Moreover, this method honors any description set with
Descriptable.as(String, Object...)
or overridden error message defined by the user withoverridingErrorMessage(String, Object...)
.This method also sets the "actual" and "expected" fields of the assertion if available (eg, if OpenTest4J is on the path). This aids IDEs to produce visual diffs of the resulting values.
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)) { throw failureWithActualExpected(actual.getName(), name, "Expected character's name to be <%s> but was <%s>", name, actual.getName()); } // return the current assertion for method chaining return this; }
- Parameters:
actual
- the actual object that was found during the testexpected
- the object that was expectederrorMessageFormat
- the error message to formatarguments
- the arguments referenced by the format specifiers in the errorMessage string.- Returns:
- The generated assertion error.
- See Also:
-
throwAssertionError
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
.
-
assertionError
-
isElementOfCustomAssert
-
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
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
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
Verifies that the actual value is equal to the given one.Example:
// assertions succeed assertThat("abc").isEqualTo("abc"); assertThat(new HashMap<String, Integer>()).isEqualTo(new HashMap<String, Integer>()); // assertions fail assertThat("abc").isEqualTo("123"); assertThat(new ArrayList<String>()).isEqualTo(1);
-
isNotEqualTo
Verifies that the actual value is not equal to the given one.Example:
// assertions succeed assertThat("abc").isNotEqualTo("123"); assertThat(new ArrayList<String>()).isNotEqualTo(1); // assertions 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 succeeds assertThat(value).isNull(); // assertions fail assertThat("abc").isNull(); assertThat(new HashMap<String, Integer>()).isNull();
-
isNotNull
Verifies that the actual value is notnull
.Example:
// assertions succeed assertThat("abc").isNotNull(); assertThat(new HashMap<String, Integer>()).isNotNull(); // assertions fails String value = null; assertThat(value).isNotNull();
-
isSameAs
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
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
Verifies that the actual value is present in the given array of values.This assertion always fails if the given array of values is empty.
Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya }; // assertion succeeds assertThat(nenya).isIn(elvesRings); // assertions fail assertThat(oneRing).isIn(elvesRings); assertThat(oneRing).isIn(new Ring[0]);
-
isNotIn
Verifies that the actual value is not present in the given array of values.This assertion always succeeds if the given array of values is empty.
Example:
Ring[] elvesRings = new Ring[] { vilya, nenya, narya }; // assertions succeed assertThat(oneRing).isNotIn(elvesRings); assertThat(oneRing).isNotIn(new Ring[0]); // assertions fails: assertThat(nenya).isNotIn(elvesRings);
-
isIn
Verifies that the actual value is present in the given iterable.This assertion always fails if the given iterable is empty.
Example:
Iterable<Ring> elvesRings = list(vilya, nenya, narya); // assertion succeeds assertThat(nenya).isIn(elvesRings); // assertions fail: assertThat(oneRing).isIn(elvesRings); assertThat(oneRing).isIn(emptyList());
-
isNotIn
Verifies that the actual value is not present in the given iterable.This assertion always succeeds if the given iterable is empty.
Example:
Iterable<Ring> elvesRings = list(vilya, nenya, narya); // assertions succeed: assertThat(oneRing).isNotIn(elvesRings); assertThat(oneRing).isNotIn(emptyList()); // assertions fails: assertThat(nenya).isNotIn(elvesRings);
-
is
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:
-
isNot
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:
-
has
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:
-
doesNotHave
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:
-
satisfies
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:
-
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 succeeds Object string = "abc"; assertThat(string).asInstanceOf(InstanceOfAssertFactories.STRING).startsWith("ab"); Object integer = 1; assertThat(integer).asInstanceOf(InstanceOfAssertFactories.INTEGER).isNotZero(); // assertions fails 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:
-
isInstanceOf
Verifies that the actual value is an instance of the given type.Example:
// assertions succeed assertThat("abc").isInstanceOf(String.class); assertThat(new HashMap<String, Integer>()).isInstanceOf(HashMap.class); assertThat(new HashMap<String, Integer>()).isInstanceOf(Map.class); // assertions 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
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
Verifies that the actual value is an instance of any of the given types.Example:
// assertions succeed 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 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
Verifies that the actual value is not an instance of the given type.Example:
// assertions succeed assertThat(1).isNotInstanceOf(Double.class); assertThat(new ArrayList<String>()).isNotInstanceOf(LinkedList.class); // assertions 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
Verifies that the actual value is not an instance of any of the given types.Example:
// assertions succeed assertThat(1).isNotInstanceOfAny(Double.class, Float.class); assertThat(new ArrayList<String>()).isNotInstanceOfAny(LinkedList.class, Vector.class); // assertions 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
Verifies that the actual value has the same class as the given object.Example:
// assertions succeed assertThat(1).hasSameClassAs(2); assertThat("abc").hasSameClassAs("123"); assertThat(new ArrayList<String>()).hasSameClassAs(new ArrayList<Integer>()); // assertions 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
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.
-
doesNotHaveToString
Verifies that actualactual.toString()
is not equal to the givenString
.Example :
CartoonCharacter homer = new CartoonCharacter("Homer"); // Instead of writing ... assertThat(homer.toString()).isNotEqualTo("Marge"); // ... you can simply write: assertThat(homer).doesNotHaveToString("Marge");
- Specified by:
doesNotHaveToString
in interfaceAssert<SELF extends AbstractAssert<SELF,
ACTUAL>, ACTUAL> - Parameters:
otherToString
- the String to check against.- Returns:
- this assertion object.
-
doesNotHaveSameClassAs
Verifies that the actual value does not have the same class as the given object.Example:
// assertions succeed assertThat(1).doesNotHaveSameClassAs("abc"); assertThat(new ArrayList<String>()).doesNotHaveSameClassAs(new LinkedList<String>()); // assertions 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
Verifies that the actual value is exactly an instance of the given type.Example:
// assertions succeed assertThat("abc").isExactlyInstanceOf(String.class); assertThat(new ArrayList<String>()).isExactlyInstanceOf(ArrayList.class); assertThat(new HashMap<String, Integer>()).isExactlyInstanceOf(HashMap.class); // assertions 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
Verifies that the actual value is not exactly an instance of given type.Example:
// assertions succeed assertThat(1).isNotExactlyInstanceOf(String.class); assertThat(new ArrayList<String>()).isNotExactlyInstanceOf(List.class); assertThat(new HashMap<String, Integer>()).isNotExactlyInstanceOf(Map.class); // assertions 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
Verifies that the actual value type is in given types.Example:
// assertions succeed assertThat(new HashMap<String, Integer>()).isOfAnyClassIn(HashMap.class, TreeMap.class); assertThat(new ArrayList<String>()).isOfAnyClassIn(ArrayList.class, LinkedList.class); // assertions 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
Verifies that the actual value type is not in given types.Example:
// assertions succeed assertThat(new HashMap<String, Integer>()).isNotOfAnyClassIn(Map.class, TreeMap.class); assertThat(new ArrayList<String>()).isNotOfAnyClassIn(LinkedList.class, List.class); // assertions 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
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 succeeds assertThat(sortedListAsObject).asList().isSorted(); Object unsortedListAsObject = Arrays.asList(3, 1, 2); // assertions fails assertThat(unsortedListAsObject).asList().isSorted();
-
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 succeeds assertThat(stringAsObject).asString().contains("hello"); // assertions fails assertThat(stringAsObject).asString().contains("holla");
-
descriptionText
The description of this assertion set withDescriptable.describedAs(String, Object...)
ordescribedAs(Description)
.- Returns:
- the description String representation of this assertion.
-
overridingErrorMessage
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.
-
overridingErrorMessage
Overrides AssertJ default error message by the given one.The new error message is only built if the assertion fails (by consuming the given supplier), this is useful if building messages is expensive.
You must set the message before calling the assertion otherwise it is ignored as the failing assertion breaks the call chain by throwing an
AssertionError
.Example :
assertThat(player.isRookie()).overridingErrorMessage(() -> "Expecting Player to be a rookie but was not.") .isTrue();
- Parameters:
supplier
- the supplier supplies error message that will replace the default one provided by Assertj.- Returns:
- this assertion object.
-
withFailMessage
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.
-
withFailMessage
Alternative method foroverridingErrorMessage(java.lang.String, java.lang.Object...)
The new error message is only built if the assertion fails (by consuming the given supplier), this is useful if building messages is expensive.
You must set the message before calling the assertion otherwise it is ignored as the failing assertion breaks the call chain by throwing an
AssertionError
.Example:
assertThat(player.isRookie()).withFailMessage(() -> "Expecting Player to be a rookie but was not.") .isTrue();
- Parameters:
supplier
- the supplier supplies error message that will replace the default one provided by Assertj.- Returns:
- this assertion object.
-
usingComparator
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
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
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
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.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.
-
hashCode
public int hashCode()Always returns 1. -
matches
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
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
Verifies that the actual object satisfied the given requirements expressed asConsumer
s.This is useful to perform a group of assertions on a single object, each passed assertion is evaluated and all failures are reported (to be precise each assertion can lead to one failure max).
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> redLightSaber = jedi -> assertThat(jedi.getLightSaberColor()).isEqualTo("Red"); Consumer<Jedi> greenLightSaber = jedi -> assertThat(jedi.getLightSaberColor()).isEqualTo("Green"); Consumer<Jedi> notDarth = jedi -> assertThat(jedi.getName()).doesNotContain("Darth"); Consumer<Jedi> darth = jedi -> assertThat(jedi.getName()).contains("Darth"); // assertions succeed: assertThat(yoda).satisfies(greenLightSaber); assertThat(luke).satisfies(greenLightSaber, notDarth); // assertions fail: Jedi vader = new Jedi("Darth Vader", "Red"); assertThat(vader).satisfies(greenLightSaber); assertThat(vader).satisfies(darth, greenLightSaber); assertThat(vader).satisfies(greenLightSaber, notDarth);
In the following example,
satisfies
prevents the need to 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), stats -> assertThat(stats.assistsPerGame).isGreaterThan(7.2), stats -> 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 any given Consumer is null
-
satisfies
Verifies that the actual object satisfied the given requirements expressed asThrowingConsumer
s.This is the same assertion as
satisfies(Consumer[])
except that aThrowingConsumer
rethrows checked exceptions asRuntimeException
. More precisely,RuntimeException
andAssertionError
are rethrown as they are andThrowable
wrapped in aRuntimeException
. If each assertion is passed as a separate argument, all of them will be evaluated and assertion error will contain all failures.Example:
// read() throws IOException ThrowingConsumer<Reader> hasReachedEOF = reader -> assertThat(reader.read()).isEqualTo(-1); ThrowingConsumer<Reader> nextCharacterA = reader -> assertThat(reader.read()).isEqualTo('a'); ThrowingConsumer<Reader> nextCharacterB = reader -> assertThat(reader.read()).isEqualTo('b'); ThrowingConsumer<Reader> nextCharacterZ = reader -> assertThat(reader.read()).isEqualTo('z'); // alphabet.txt contains: abcdefghijklmnopqrstuvwxyz // empty.txt is empty // assertion succeeds: assertThat(new FileReader("empty.txt")).satisfies(hasReachedEOF); assertThat(new FileReader("alphabet.txt")).satisfies(nextCharacterA, nextCharacterB); // assertion fails: assertThat(new FileReader("alphabet.txt")).satisfies(nextCharacterA, hasReachedEOF); assertThat(new FileReader("alphabet.txt")).satisfies(nextCharacterB, nextCharacterZ);
- Parameters:
assertions
- the 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 nullRuntimeException
- rethrown as is by the givenThrowingConsumer
or wrapping anyThrowable
.AssertionError
- rethrown as is by the givenThrowingConsumer
- Since:
- 3.21.0
-
satisfiesForProxy
- Throws:
AssertionError
-
satisfiesAnyOf
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 withDescriptable.as(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> isDwarf = tolkienCharacter -> assertThat(tolkienCharacter.getRace()).isEqualTo(DWARF); // assertion succeeds: assertThat(frodo).satisfiesAnyOf(isElf, isHobbit, isDwarf); // assertion fails: TolkienCharacter boromir = new TolkienCharacter("Boromir", MAN); assertThat(boromir).satisfiesAnyOf(isHobbit, isElf, isDwarf);
- Parameters:
assertions
- the 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
Verifies that the actual object under test satisfies at least one of the given assertions group expressed asThrowingConsumer
s.This allows users to perform OR like assertions since only one the assertions group has to be met.
This is the same assertion as
satisfiesAnyOf(Consumer...)
but the given consumers can throw checked exceptions.
More precisely,RuntimeException
andAssertionError
are rethrown as they are andThrowable
wrapped in aRuntimeException
.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 withDescriptable.as(String, Object...)
).Example:
// read() throws IOException ThrowingConsumer<Reader> hasReachedEOF = reader -> assertThat(reader.read()).isEqualTo(-1); ThrowingConsumer<Reader> startsWithZ = reader -> assertThat(reader.read()).isEqualTo('Z'); // assertion succeeds as the file is empty (note that if hasReachedEOF was declared as a Consumer<Reader> the following line would not compile): assertThat(new FileReader("empty.txt")).satisfiesAnyOf(hasReachedEOF, startsWithZ); // alphabet.txt contains: abcdefghijklmnopqrstuvwxyz // assertion fails as alphabet.txt is not empty and starts with 'a': assertThat(new FileReader("alphabet.txt")).satisfiesAnyOf(hasReachedEOF, startsWithZ);
- Parameters:
assertions
- the 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 nullRuntimeException
- rethrown as is by the givenThrowingConsumer
or wrapping anyThrowable
.AssertionError
- rethrown as is by the givenThrowingConsumer
- Since:
- 3.21.0
-
satisfiesAnyOfForProxy
protected SELF satisfiesAnyOfForProxy(Consumer<? super ACTUAL>[] assertionsGroups) throws AssertionError - Throws:
AssertionError
-
setCustomRepresentation
-
setPrintAssertionsDescription
public static void setPrintAssertionsDescription(boolean printAssertionsDescription) -
setDescriptionConsumer
-
hasSameHashCodeAs
Verifies that the actual object has the same hashCode as the given object.Example:
// assertions succeed assertThat(42L).hasSameHashCodeAs(42L); assertThat("The Force").hasSameHashCodeAs("The Force"); assertThat(new Jedi("Yoda", "Blue")).hasSameHashCodeAs(new Jedi("Yoda", "Blue")); // assertions fail assertThat(42L).hasSameHashCodeAs(2501L); assertThat(null).hasSameHashCodeAs("The Force"); assertThat("The Force").hasSameHashCodeAs("Awakens");
- Specified by:
hasSameHashCodeAs
in interfaceAssert<SELF extends AbstractAssert<SELF,
ACTUAL>, ACTUAL> - Parameters:
other
- the object to check hashCode against.- Returns:
- this assertion object.
-
doesNotHaveSameHashCodeAs
Verifies that the actual object does not have the same hashCode as the given object.Example:
// assertions succeed assertThat(42L).doesNotHaveSameHashCodeAs(2501L); assertThat("The Force").doesNotHaveSameHashCodeAs("Awakens"); // assertions fail assertThat(42L).doesNotHaveSameHashCodeAs(42L); assertThat("The Force").doesNotHaveSameHashCodeAs("The Force"); assertThat(new Jedi("Yoda", "Blue")).doesNotHaveSameHashCodeAs(new Jedi("Yoda", "Blue"));
- Specified by:
doesNotHaveSameHashCodeAs
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>, newListAssertInstanceE, ObjectAssert<E>> (List<? extends E> newActual) Create aAbstractListAssert
from the given list.this method avoids code duplication when features like extracting/asList need to create a new list assertions.
- Type Parameters:
E
- the type of elements.- Parameters:
newActual
- new list under test- Returns:
- a new
AbstractListAssert
.
-
usingRecursiveComparison
protected RecursiveComparisonAssert<?> usingRecursiveComparison(RecursiveComparisonConfiguration recursiveComparisonConfiguration) -
usingRecursiveComparison
-
extracting
protected <ASSERT extends AbstractAssert<?,?>> ASSERT extracting(String propertyOrField, AssertFactory<Object, ASSERT> assertFactory) Extracts the value of given field/property from the object under test and creates a new assertion object using the given assert factory.If the object under test is a
Map
, thepropertyOrField
parameter is used as a key to the map.Nested field/property is supported, specifying "address.street.number" is equivalent to get the value corresponding to actual.getAddress().getStreet().getNumber()
Private field can be extracted unless you call
Assertions.setAllowExtractingPrivateFields(false)
.- Type Parameters:
ASSERT
- the type of the resultingAssert
- Parameters:
propertyOrField
- the property/field to extract from the initial object under testassertFactory
- the factory for the creation of the newAssert
- Returns:
- the new
Assert
instance - Throws:
AssertionError
- if the object under test isnull
- Since:
- 3.16.0
- See Also:
-
extracting
protected <T,ASSERT extends AbstractAssert<?, ASSERT extracting?>> (Function<? super ACTUAL, ? extends T> extractor, AssertFactory<T, ASSERT> assertFactory) Uses the givenFunction
to extract a value from the object under test and creates a new assertion object using the given assert factory.- Type Parameters:
T
- the expected extracted value typeASSERT
- the type of the resultingAssert
- Parameters:
extractor
- the extractor function used to extract the value from the object under testassertFactory
- the factory for the creation of the newAssert
- Returns:
- the new
Assert
instance - Throws:
AssertionError
- if the object under test isnull
- Since:
- 3.16.0
- See Also:
-
areEqual
Deprecated.ComparisonStrategy
will become part of the public API in the next major release and this method will be removed.Returns true if actual and other are equal according to the current comparison strategy.- Parameters:
actual
- the object to compare to otherother
- the object to compare to actual- Returns:
- true if actual and other are equal according to the underlying comparison strategy.
- Since:
- 3.23.0
-
ComparisonStrategy
will become part of the public API in the next major release and this method will be removed.