SELF - the "self" type of this assertion class. Please read "Emulating
'self types' using Java Generics to simplify fluent API implementation" for more details.ACTUAL - the type of the "actual" value.public interface Assert<SELF extends Assert<SELF,ACTUAL>,ACTUAL> extends Descriptable<SELF>, ExtensionPoints<SELF,ACTUAL>
| Modifier and Type | Method and Description |
|---|---|
<ASSERT extends AbstractAssert<?,?>> |
asInstanceOf(InstanceOfAssertFactory<?,ASSERT> instanceOfAssertFactory)
Uses an
InstanceOfAssertFactory to verify that the actual value is an instance of a given type and to produce
a new Assert 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.
|
AbstractCharSequenceAssert<?,String> |
asString()
Returns a String assertion for the
toString() of the actual
value, to allow chaining of String-specific assertions from this call. |
SELF |
doesNotHaveSameClassAs(Object other)
Verifies that the actual value does not have the same class as the given object.
|
SELF |
doesNotHaveSameHashCodeAs(Object other)
Verifies that the actual object does not have the same hashCode as the given object.
|
SELF |
doesNotHaveToString(String otherToString)
Verifies that actual
actual.toString() is not equal to the given String. |
boolean |
equals(Object obj)
Deprecated.
Throws
equals(Object) instead of |
SELF |
hasSameClassAs(Object other)
Verifies that the actual value has the same class as the given object.
|
SELF |
hasSameHashCodeAs(Object other)
Verifies that the actual object has the same hashCode as the given object.
|
SELF |
hasToString(String expectedToString)
Verifies that actual
actual.toString() is equal to the given String. |
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 iterable.
|
SELF |
isIn(Object... values)
Verifies that the actual value is present in the given array of values.
|
SELF |
isInstanceOf(Class<?> type)
Verifies that the actual value is an instance of the given type.
|
SELF |
isInstanceOfAny(Class<?>... types)
Verifies that the actual value is an instance of any of the given types.
|
<T> SELF |
isInstanceOfSatisfying(Class<T> type,
Consumer<T> requirements)
Verifies that the actual value is an instance of the given type satisfying the given requirements expressed as a
Consumer. |
SELF |
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 iterable.
|
SELF |
isNotIn(Object... values)
Verifies that the actual value is not present in the given array of values.
|
SELF |
isNotInstanceOf(Class<?> type)
Verifies that the actual value is not an instance of the given type.
|
SELF |
isNotInstanceOfAny(Class<?>... types)
Verifies that the actual value is not an instance of any of the given types.
|
SELF |
isNotNull()
Verifies that the actual value is not
null. |
SELF |
isNotOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is not in given types.
|
SELF |
isNotSameAs(Object other)
Verifies that the actual value is not the same as the given one, ie using == comparison.
|
void |
isNull()
Verifies that the actual value is
null. |
SELF |
isOfAnyClassIn(Class<?>... types)
Verifies that the actual value type is in given types.
|
SELF |
isSameAs(Object expected)
Verifies that the actual value is the same as the given one, ie using == comparison.
|
SELF |
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.
|
SELF |
withRepresentation(Representation representation)
Use the given
Representation to describe/represent values in AssertJ error messages. |
SELF |
withThreadDumpOnError()
In case of an assertion error, a thread dump will be printed to
System.err. |
as, as, as, describedAs, describedAsdoesNotHave, has, is, isNot, satisfiesSELF isEqualTo(Object expected)
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);expected - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is not equal to the given one.SELF isNotEqualTo(Object other)
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>());other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is equal to the given one.void isNull()
null.
Example:
String value = null;
// assertion succeeds
assertThat(value).isNull();
// assertions fail
assertThat("abc").isNull();
assertThat(new HashMap<String, Integer>()).isNull();AssertionError - if the actual value is not null.SELF isNotNull()
null.
Example:
// assertions succeed
assertThat("abc").isNotNull();
assertThat(new HashMap<String, Integer>()).isNotNull();
// assertions fails
String value = null;
assertThat(value).isNotNull();this assertion object.AssertionError - if the actual value is null.SELF isSameAs(Object expected)
Example:
// Name is a class with first and last fields, two Names are equals if both first and last are equals.
Name tyrion = new Name("Tyrion", "Lannister");
Name alias = tyrion;
Name clone = new Name("Tyrion", "Lannister");
// assertions succeed:
assertThat(tyrion).isSameAs(alias)
.isEqualTo(clone);
// assertion fails:
assertThat(tyrion).isSameAs(clone);expected - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is not the same as the given one.SELF isNotSameAs(Object other)
Example:
// Name is a class with first and last fields, two Names are equals if both first and last are equals.
Name tyrion = new Name("Tyrion", "Lannister");
Name alias = tyrion;
Name clone = new Name("Tyrion", "Lannister");
// assertions succeed:
assertThat(clone).isNotSameAs(tyrion)
.isEqualTo(tyrion);
// assertion fails:
assertThat(alias).isNotSameAs(tyrion);other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is the same as the given one.SELF isIn(Object... 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]);values - the given array to search the actual value in.this assertion object.NullPointerException - if the given array is null.AssertionError - if the actual value is not present in the given array.SELF isNotIn(Object... 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);values - the given array to search the actual value in.this assertion object.NullPointerException - if the given array is null.AssertionError - if the actual value is present in the given array.SELF isIn(Iterable<?> values)
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());values - the given iterable to search the actual value in.this assertion object.NullPointerException - if the given collection is null.AssertionError - if the actual value is not present in the given collection.SELF isNotIn(Iterable<?> values)
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);values - the given iterable to search the actual value in.this assertion object.NullPointerException - if the given collection is null.AssertionError - if the actual value is present in the given collection.SELF usingComparator(Comparator<? super ACTUAL> customComparator)
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);customComparator - the comparator to use for the incoming assertion checks.this assertion object.NullPointerException - if the given comparator is null.SELF usingComparator(Comparator<? super ACTUAL> customComparator, String customComparatorDescription)
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);customComparator - the comparator to use for the incoming assertion checks.customComparatorDescription - comparator description to be used in assertion error messagesthis assertion object.NullPointerException - if the given comparator is null.SELF usingDefaultComparator()
This method should be used to disable a custom comparison strategy set by calling usingComparator.
this assertion object.<ASSERT extends AbstractAssert<?,?>> ASSERT asInstanceOf(InstanceOfAssertFactory<?,ASSERT> instanceOfAssertFactory)
InstanceOfAssertFactory to verify that the actual value is an instance of a given type and to produce
a new Assert narrowed to that type.
InstanceOfAssertFactories provides static factories for all the types supported by Assertions#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);ASSERT - the type of the resulting Assert.instanceOfAssertFactory - the factory which verifies the type and creates the new Assert.Assert instance.NullPointerException - if the given factory is null.InstanceOfAssertFactory,
InstanceOfAssertFactoriesSELF isInstanceOf(Class<?> 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);type - the type to check the actual value against.NullPointerException - if the given type is null.AssertionError - if the actual value is null.AssertionError - if the actual value is not an instance of the given type.<T> SELF isInstanceOfSatisfying(Class<T> type, Consumer<T> requirements)
Consumer.
This is useful to perform a group of assertions on a single object after checking its runtime type.
Example:
// second constructor parameter is the light saber color
Object yoda = new Jedi("Yoda", "Green");
Object luke = new Jedi("Luke Skywalker", "Green");
Consumer<Jedi> jediRequirements = jedi -> {
assertThat(jedi.getLightSaberColor()).isEqualTo("Green");
assertThat(jedi.getName()).doesNotContain("Dark");
};
// assertions succeed:
assertThat(yoda).isInstanceOfSatisfying(Jedi.class, jediRequirements);
assertThat(luke).isInstanceOfSatisfying(Jedi.class, jediRequirements);
// assertions fail:
Jedi vader = new Jedi("Vader", "Red");
assertThat(vader).isInstanceOfSatisfying(Jedi.class, jediRequirements);
// not a Jedi !
assertThat("foo").isInstanceOfSatisfying(Jedi.class, jediRequirements);T - the generic type to check the actual value against.type - the type to check the actual value against.requirements - the requirements expressed as a Consumer.NullPointerException - if the given type is null.NullPointerException - if the given Consumer is null.AssertionError - if the actual value is null.AssertionError - if the actual value is not an instance of the given type.SELF isInstanceOfAny(Class<?>... 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);types - the types to check the actual value against.AssertionError - if the actual value is null.AssertionError - if the actual value is not an instance of any of the given types.NullPointerException - if the given array of types is null.NullPointerException - if the given array of types contains nulls.SELF isNotInstanceOf(Class<?> 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);type - the type to check the actual value against.NullPointerException - if the given type is null.AssertionError - if the actual value is null.AssertionError - if the actual value is an instance of the given type.SELF isNotInstanceOfAny(Class<?>... 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);types - the types to check the actual value against.AssertionError - if the actual value is null.AssertionError - if the actual value is an instance of any of the given types.NullPointerException - if the given array of types is null.NullPointerException - if the given array of types contains nulls.SELF hasSameClassAs(Object other)
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>());other - the object to check type against.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.SELF hasToString(String expectedToString)
actual.toString() is equal to the given String.
Example :
CartoonCharacter homer = new CartoonCharacter("Homer");
// Instead of writing ...
assertThat(homer.toString()).isEqualTo("Homer");
// ... you can simply write:
assertThat(homer).hasToString("Homer");expectedToString - the expected String description of actual.AssertionError - if actual.toString() result is not equal to the given String.AssertionError - if actual is null.SELF doesNotHaveToString(String otherToString)
actual.toString() is not equal to the given String.
Example :
CartoonCharacter homer = new CartoonCharacter("Homer");
// Instead of writing ...
assertThat(homer.toString()).isNotEqualTo("Marge");
// ... you can simply write:
assertThat(homer).doesNotHaveToString("Marge");otherToString - the String to check against.AssertionError - if actual.toString() result is equal to the given String.AssertionError - if actual is null.SELF doesNotHaveSameClassAs(Object other)
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>());other - the object to check type against.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.SELF isExactlyInstanceOf(Class<?> 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);type - the type to check the actual value against.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.SELF isNotExactlyInstanceOf(Class<?> 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);type - the type to check the actual value against.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.SELF isOfAnyClassIn(Class<?>... 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);types - the types to check the actual value against.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.SELF isNotOfAnyClassIn(Class<?>... 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);types - the types to check the actual value against.AssertionError - if the actual value type is in given types.NullPointerException - if the actual value is null.NullPointerException - if the given types is null.AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> asList()
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();AbstractCharSequenceAssert<?,String> asString()
toString() 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");@Deprecated boolean equals(Object obj)
UnsupportedOperationExceptionequals(Object) instead of isEqualTo(Object)equals in class ObjectUnsupportedOperationException - if this method is called.SELF withThreadDumpOnError()
System.err.
Example :
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)SELF withRepresentation(Representation representation)
Representation to describe/represent values in AssertJ error messages.
The usual way to introduce a new Representation is to extend StandardRepresentation
and override any existing toStringOf methods that don't suit you. For example you can control
Date formatting by overriding StandardRepresentation.toStringOf(Date)).
You can also control other types format by overriding StandardRepresentation.toStringOf(Object))
calling your formatting method first and then fall back to the default representation by calling super.toStringOf(Object).
Example :
private class Example {}
private class CustomRepresentation extends StandardRepresentation {
// override needed to hook specific formatting
@Override
public String toStringOf(Object o) {
if (o instanceof Example) return "Example";
// fall back to default formatting
return super.toStringOf(o);
}
// change String representation
@Override
protected String toStringOf(String s) {
return "$" + s + "$";
}
}
// next assertion fails with error : "expected:<[null]> but was:<[Example]>"
Example example = new Example();
assertThat(example).withRepresentation(new CustomRepresentation())
.isNull(); // example is not null !
// next assertion fails ...
assertThat("foo").withRepresentation(new CustomRepresentation())
.startsWith("bar");
// ... with error :
Expecting:
<$foo$>
to start with:
<$bar$>representation - Describe/represent values in AssertJ error messages.SELF hasSameHashCodeAs(Object other)
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");other - the object to check hashCode against.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.SELF doesNotHaveSameHashCodeAs(Object other)
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")); other - the object to check hashCode against.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.Copyright © 2025. All rights reserved.