Interface Assert<SELF extends Assert<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 Superinterfaces:
Descriptable<SELF>
,ExtensionPoints<SELF,
ACTUAL>
- All Known Implementing Classes:
Abstract2DArrayAssert
,AbstractArrayAssert
,AbstractAssert
,AbstractAtomicFieldUpdaterAssert
,AbstractAtomicReferenceAssert
,AbstractBigDecimalAssert
,AbstractBigDecimalScaleAssert
,AbstractBigIntegerAssert
,AbstractBooleanArrayAssert
,AbstractBooleanAssert
,AbstractByteArrayAssert
,AbstractByteAssert
,AbstractCharacterAssert
,AbstractCharArrayAssert
,AbstractCharSequenceAssert
,AbstractClassAssert
,AbstractCollectionAssert
,AbstractComparableAssert
,AbstractCompletableFutureAssert
,AbstractDateAssert
,AbstractDoubleArrayAssert
,AbstractDoubleAssert
,AbstractDurationAssert
,AbstractEnumerableAssert
,AbstractFileAssert
,AbstractFileSizeAssert
,AbstractFloatArrayAssert
,AbstractFloatAssert
,AbstractFutureAssert
,AbstractInputStreamAssert
,AbstractInstantAssert
,AbstractIntArrayAssert
,AbstractIntegerAssert
,AbstractIterableAssert
,AbstractIterableSizeAssert
,AbstractIteratorAssert
,AbstractListAssert
,AbstractLocalDateAssert
,AbstractLocalDateTimeAssert
,AbstractLocalTimeAssert
,AbstractLongAdderAssert
,AbstractLongArrayAssert
,AbstractLongAssert
,AbstractMapAssert
,AbstractMapSizeAssert
,AbstractMatcherAssert
,AbstractObjectArrayAssert
,AbstractObjectAssert
,AbstractOffsetDateTimeAssert
,AbstractOffsetTimeAssert
,AbstractOptionalAssert
,AbstractOptionalDoubleAssert
,AbstractOptionalIntAssert
,AbstractOptionalLongAssert
,AbstractPathAssert
,AbstractPeriodAssert
,AbstractPredicateAssert
,AbstractShortArrayAssert
,AbstractShortAssert
,AbstractSpliteratorAssert
,AbstractStringAssert
,AbstractTemporalAssert
,AbstractThrowableAssert
,AbstractUniversalComparableAssert
,AbstractUriAssert
,AbstractUrlAssert
,AbstractZonedDateTimeAssert
,AtomicBooleanAssert
,AtomicIntegerArrayAssert
,AtomicIntegerAssert
,AtomicIntegerFieldUpdaterAssert
,AtomicLongArrayAssert
,AtomicLongAssert
,AtomicLongFieldUpdaterAssert
,AtomicMarkableReferenceAssert
,AtomicReferenceArrayAssert
,AtomicReferenceAssert
,AtomicReferenceFieldUpdaterAssert
,AtomicStampedReferenceAssert
,BigDecimalAssert
,BigDecimalScaleAssert
,BigIntegerAssert
,Boolean2DArrayAssert
,BooleanArrayAssert
,BooleanAssert
,Byte2DArrayAssert
,ByteArrayAssert
,ByteAssert
,Char2DArrayAssert
,CharacterAssert
,CharArrayAssert
,CharSequenceAssert
,ClassAssert
,ClassBasedNavigableIterableAssert
,ClassBasedNavigableListAssert
,CollectionAssert
,CompletableFutureAssert
,DateAssert
,Double2DArrayAssert
,DoubleArrayAssert
,DoubleAssert
,DoublePredicateAssert
,DurationAssert
,FactoryBasedNavigableIterableAssert
,FactoryBasedNavigableListAssert
,FileAssert
,FileSizeAssert
,Float2DArrayAssert
,FloatArrayAssert
,FloatAssert
,FutureAssert
,GenericComparableAssert
,InputStreamAssert
,InstantAssert
,Int2DArrayAssert
,IntArrayAssert
,IntegerAssert
,IntPredicateAssert
,IterableAssert
,IterableSizeAssert
,IteratorAssert
,ListAssert
,LocalDateAssert
,LocalDateTimeAssert
,LocalTimeAssert
,Long2DArrayAssert
,LongAdderAssert
,LongArrayAssert
,LongAssert
,LongPredicateAssert
,MapAssert
,MapSizeAssert
,MatcherAssert
,Object2DArrayAssert
,ObjectArrayAssert
,ObjectAssert
,OffsetDateTimeAssert
,OffsetTimeAssert
,OptionalAssert
,OptionalDoubleAssert
,OptionalIntAssert
,OptionalLongAssert
,PathAssert
,PeriodAssert
,PredicateAssert
,RecursiveAssertionAssert
,RecursiveComparisonAssert
,Short2DArrayAssert
,ShortArrayAssert
,ShortAssert
,SoftThrowableAssertAlternative
,SpliteratorAssert
,StringAssert
,ThrowableAssert
,ThrowableAssertAlternative
,UniversalComparableAssert
,UriAssert
,UrlAssert
,ZonedDateTimeAssert
- Author:
- Yvonne Wang, Alex Ruiz, Nicolas François, Mikhail Mazursky
-
Method Summary
Modifier and TypeMethodDescription<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.asString()
Returns a String assertion for thetoString()
of the actual value, to allow chaining of String-specific assertions from this call.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.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
.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
.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.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.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 interface org.assertj.core.api.Descriptable
as, as, as, describedAs, describedAs
Methods inherited from interface org.assertj.core.api.ExtensionPoints
doesNotHave, has, is, isNot, satisfies
-
Method Details
-
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);
- Parameters:
expected
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value is not equal to the given one.
-
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>());
- Parameters:
other
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value is equal to the given one.
-
isNull
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();
- Throws:
AssertionError
- if the actual value is notnull
.
-
isNotNull
SELF 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();
- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value isnull
.
-
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);
- Parameters:
expected
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value is not the same as the given one.
-
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);
- Parameters:
other
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value is the same as the given one.
-
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]);
- Parameters:
values
- the given array to search the actual value in.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given array isnull
.AssertionError
- if the actual value is not present in the given array.
-
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);
- Parameters:
values
- the given array to search the actual value in.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given array isnull
.AssertionError
- if the actual value is present in the given array.
-
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());
- Parameters:
values
- the given iterable to search the actual value in.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given collection isnull
.AssertionError
- if the actual value is not present in the given iterable.
-
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);
- Parameters:
values
- the given iterable to search the actual value in.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given iterable isnull
.AssertionError
- if the actual value is present in the given iterable.
-
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);
- Parameters:
customComparator
- the comparator to use for the incoming assertion checks.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given comparator isnull
.
-
usingComparator
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);
- 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.- Throws:
NullPointerException
- if the given comparator isnull
.
-
usingDefaultComparator
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
.- Returns:
this
assertion object.
-
asInstanceOf
<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);
- 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. - Throws:
NullPointerException
- if the given factory isnull
.- Since:
- 3.13.0
- 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);
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
- Throws:
NullPointerException
- if the given type isnull
.AssertionError
- if the actual value isnull
.AssertionError
- if the actual value is not an instance of the given type.
-
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);
- 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.
- Throws:
NullPointerException
- if the given type isnull
.NullPointerException
- if the given Consumer isnull
.AssertionError
- if the actual value isnull
.AssertionError
- if the actual value is not an instance of the given type.
-
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);
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value isnull
.AssertionError
- if the actual value is not an instance of any of the given types.NullPointerException
- if the given array of types isnull
.NullPointerException
- if the given array of types containsnull
s.
-
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);
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
- Throws:
NullPointerException
- if the given type isnull
.AssertionError
- if the actual value isnull
.AssertionError
- if the actual value is an instance of the given type.
-
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);
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value isnull
.AssertionError
- if the actual value is an instance of any of the given types.NullPointerException
- if the given array of types isnull
.NullPointerException
- if the given array of types containsnull
s.
-
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>());
- Parameters:
other
- the object to check type against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual has not the same type has the given object.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.
-
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");
- Parameters:
expectedToString
- the expected String description of actual.- Returns:
- this assertion object.
- Throws:
AssertionError
- ifactual.toString()
result is not equal to the givenString
.AssertionError
- if actual isnull
.
-
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");
- Parameters:
otherToString
- the String to check against.- Returns:
- this assertion object.
- Throws:
AssertionError
- ifactual.toString()
result is equal to the givenString
.AssertionError
- if actual isnull
.
-
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>());
- Parameters:
other
- the object to check type against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual has the same type has the given object.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.
-
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);
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual is not exactly an instance of given type.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.
-
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);
- Parameters:
type
- the type to check the actual value against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual is exactly an instance of given type.NullPointerException
- if the actual value is null.NullPointerException
- if the given object is null.
-
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);
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value type is not in given type.NullPointerException
- if the actual value is null.NullPointerException
- if the given types is null.
-
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);
- Parameters:
types
- the types to check the actual value against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value type is in given types.NullPointerException
- if the actual value is null.NullPointerException
- if the given types is null.
-
asList
AbstractListAssert<?,List<?>, asList()Object, ObjectAssert<Object>> 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();
- Returns:
- a list assertion object
-
asString
AbstractCharSequenceAssert<?,String> 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");
- Returns:
- a string assertion object
-
equals
Deprecated.Throws
if called. It is easy to accidentally callUnsupportedOperationException
equals(Object)
instead of
.isEqualTo(Object)
- Overrides:
equals
in classObject
- Throws:
UnsupportedOperationException
- if this method is called.
-
withThreadDumpOnError
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)
- 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$>
- Parameters:
representation
- Describe/represent values in AssertJ error messages.- Returns:
- this assertion object.
-
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");
- Parameters:
other
- the object to check hashCode against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual object is null.NullPointerException
- if the other object is null.AssertionError
- if the actual object has not the same hashCode as the given object.- Since:
- 2.9.0
-
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"));
- Parameters:
other
- the object to check hashCode against.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual object is null.NullPointerException
- if the other object is null.AssertionError
- if the actual object has the same hashCode as the given object.- Since:
- 3.19.0
-
if called.UnsupportedOperationException