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.K - the type of keys in the map.V - the type of values in the map.public abstract class AbstractMapAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>,K,V> extends AbstractObjectAssert<SELF,ACTUAL> implements EnumerableAssert<SELF,Map.Entry<? extends K,? extends V>>
Maps.actual, info, myself, objects, throwUnsupportedExceptionOnEquals| Modifier | Constructor and Description |
|---|---|
protected |
AbstractMapAssert(ACTUAL actual,
Class<?> selfType) |
| Modifier and Type | Method and Description |
|---|---|
SELF |
allSatisfy(BiConsumer<? super K,? super V> entryRequirements)
Verifies that all the actual map entries satisfy the given
entryRequirements . |
SELF |
anySatisfy(BiConsumer<? super K,? super V> entryRequirements)
Verifies that at least one map entry satisfies the given
entryRequirements . |
SELF |
as(Description description)
Sets the description of the assertion that is going to be called after.
|
SELF |
as(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
SELF |
contains(Map.Entry<? extends K,? extends V>... entries)
Verifies that the actual map contains the given entries, in any order.
|
SELF |
containsAllEntriesOf(Map<? extends K,? extends V> other)
Verifies that the actual map contains all entries of the given map, in any order.
|
SELF |
containsAnyOf(Map.Entry<? extends K,? extends V>... entries)
Verifies that the actual map contains at least one of the given entries.
|
protected SELF |
containsAnyOfForProxy(Map.Entry<? extends K,? extends V>[] entries) |
SELF |
containsEntry(K key,
V value)
Verifies that the actual map contains the given entry.
|
SELF |
containsExactly(Map.Entry<? extends K,? extends V>... entries)
Verifies that the actual map contains only the given entries and nothing else, in order.
This assertion should only be used with maps that have a consistent iteration order (i.e. |
SELF |
containsExactlyEntriesOf(Map<? extends K,? extends V> map)
Same as
containsExactly(Map.Entry[]) but handles the conversion of Map.entrySet() to array. |
protected SELF |
containsExactlyForProxy(Map.Entry<? extends K,? extends V>[] entries) |
SELF |
containsExactlyInAnyOrderEntriesOf(Map<? extends K,? extends V> map)
Same as
containsOnly(Map.Entry[]) but handles the conversion of Map.entrySet() to array. |
protected SELF |
containsForProxy(Map.Entry<? extends K,? extends V>[] entries) |
SELF |
containsKey(K key)
Verifies that the actual map contains the given key.
|
SELF |
containsKeys(K... keys)
Verifies that the actual map contains the given keys.
|
protected SELF |
containsKeysForProxy(K[] keys) |
SELF |
containsOnly(Map.Entry<? extends K,? extends V>... entries)
Verifies that the actual map contains only the given entries and nothing else, in any order.
|
protected SELF |
containsOnlyForProxy(Map.Entry<? extends K,? extends V>[] entries) |
SELF |
containsOnlyKeys(Iterable<? extends K> keys)
Verifies that the actual map contains only the given keys and nothing else, in any order.
|
SELF |
containsOnlyKeys(K... keys)
Verifies that the actual map contains only the given keys and nothing else, in any order.
|
protected SELF |
containsOnlyKeysForProxy(K[] keys) |
SELF |
containsValue(V value)
Verifies that the actual map contains the given value.
|
SELF |
containsValues(V... values)
Verifies that the actual map contains the given values.
|
protected SELF |
containsValuesForProxy(V[] values) |
SELF |
describedAs(Description description)
Sets the description of the assertion that is going to be called after.
|
SELF |
describedAs(String description,
Object... args)
Sets the description of the assertion that is going to be called after.
|
SELF |
doesNotContain(Map.Entry<? extends K,? extends V>... entries)
Verifies that the actual map does not contain the given entries.
|
SELF |
doesNotContainEntry(K key,
V value)
Verifies that the actual map does not contain the given entry.
|
protected SELF |
doesNotContainForProxy(Map.Entry<? extends K,? extends V>[] entries) |
SELF |
doesNotContainKey(K key)
Verifies that the actual map does not contain the given key.
|
SELF |
doesNotContainKeys(K... keys)
Verifies that the actual map does not contain any of the given keys.
|
protected SELF |
doesNotContainKeysForProxy(K[] keys) |
SELF |
doesNotContainValue(V value)
Verifies that the actual map does not contain the given value.
|
SELF |
doesNotHave(Condition<? super ACTUAL> condition)
Verifies that the actual value does not satisfy the given condition.
|
SELF |
doesNotHaveSameClassAs(Object other)
Verifies that the actual value does not have the same class as the given object.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
extracting(Object... keys)
Deprecated.
use
extractingByKeys(Object[]) instead |
AbstractObjectAssert<?,?> |
extracting(Object key)
Deprecated.
use
extractingByKey(Object) instead |
AbstractObjectAssert<?,V> |
extractingByKey(K key)
Extract the value of given key from the map under test, the extracted value becoming the new object under test.
|
<ASSERT extends AbstractAssert<?,?>> |
extractingByKey(K key,
InstanceOfAssertFactory<?,ASSERT> assertFactory)
Extract the value of given key from the map under test, the extracted value becoming the new object under test.
|
AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
extractingByKeys(K... keys)
Extract the values of given keys from the map under test into an array, this new array becoming
the object under test.
|
protected AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
extractingByKeysForProxy(K[] keys) |
AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> |
extractingFromEntries(Function<? super Map.Entry<K,V>,Object>... extractors)
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
extractingFromEntries(Function<? super Map.Entry<K,V>,Object> extractor)
|
protected AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> |
extractingFromEntriesForProxy(Function<? super Map.Entry<K,V>,Object>[] extractors) |
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
flatExtracting(String... keys)
Flatten the values of the given keys from the actual map under test into a new array, this new array becoming the object under test.
|
SELF |
has(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition.
|
SELF |
hasEntrySatisfying(Condition<? super K> keyCondition,
Condition<? super V> valueCondition)
Verifies that the actual map contains an entry with a key satisfying the given
keyCondition
and a value satisfying the given valueCondition. |
SELF |
hasEntrySatisfying(Condition<? super Map.Entry<K,V>> entryCondition)
Verifies that the actual map contains an entry satisfying the given
entryCondition. |
SELF |
hasEntrySatisfying(K key,
Condition<? super V> valueCondition)
Verifies that the actual map contains a value for the given
key that satisfies the given valueCondition. |
SELF |
hasEntrySatisfying(K key,
Consumer<? super V> valueRequirements)
Verifies that the actual map contains the value for given
key that satisfy given valueRequirements. |
SELF |
hasKeySatisfying(Condition<? super K> keyCondition)
Verifies that the actual map contains an entry with a key satisfying the given
keyCondition. |
SELF |
hasSameClassAs(Object other)
Verifies that the actual value has the same class as the given object.
|
SELF |
hasSameSizeAs(Iterable<?> other)
Verifies that the actual map has the same size as the given
Iterable. |
SELF |
hasSameSizeAs(Map<?,?> other)
Verifies that the actual map has the same size as the given
Map. |
SELF |
hasSameSizeAs(Object other)
Verifies that the actual map has the same size as the given array.
|
SELF |
hasSize(int expected)
Verifies that the number of values in the
Map is equal to the given one. |
SELF |
hasSizeBetween(int lowerBoundary,
int higherBoundary)
Verifies that the number of values in the
Map is between the given boundaries (inclusive). |
SELF |
hasSizeGreaterThan(int boundary)
Verifies that the number of values in the
Map is greater than the boundary. |
SELF |
hasSizeGreaterThanOrEqualTo(int boundary)
Verifies that the number of values in the
Map is greater than or equal to the boundary. |
SELF |
hasSizeLessThan(int boundary)
Verifies that the number of values in the
Map is less than the boundary. |
SELF |
hasSizeLessThanOrEqualTo(int boundary)
Verifies that the number of values in the
Map is less than or equal to the boundary. |
SELF |
hasToString(String expectedToString)
Verifies that actual
actual.toString() is equal to the given String. |
SELF |
hasValueSatisfying(Condition<? super V> valueCondition)
Verifies that the actual map contains an entry with a value satisfying the given
valueCondition. |
SELF |
is(Condition<? super ACTUAL> condition)
Verifies that the actual value satisfies the given condition.
|
void |
isEmpty()
Verifies that the
Map is empty. |
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.
|
SELF |
isNot(Condition<? super ACTUAL> condition)
Verifies that the actual value does not satisfy the given condition.
|
SELF |
isNotEmpty()
Verifies that the
Map is not empty. |
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 |
isNullOrEmpty()
Verifies that the
Map is null or empty. |
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 |
noneSatisfy(BiConsumer<? super K,? super V> entryRequirements)
Verifies that no map entry satisfies the given
entryRequirements . |
SELF |
overridingErrorMessage(String newErrorMessage,
Object... args)
Overrides AssertJ default error message by the given one.
|
AbstractMapSizeAssert<SELF,ACTUAL,K,V> |
size()
Returns an
Assert object that allows performing assertions on the size of the Map under test. |
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 |
usingDefaultElementComparator()
Deprecated.
Custom element Comparator is not supported for MapEntry comparison.
|
SELF |
usingElementComparator(Comparator<? super Map.Entry<? extends K,? extends V>> customComparator)
Deprecated.
Custom element Comparator is not supported for MapEntry comparison.
|
RecursiveComparisonAssert<?> |
usingRecursiveComparison()
Enable using a recursive field by field comparison strategy when calling the chained
RecursiveComparisonAssert, |
RecursiveComparisonAssert<?> |
usingRecursiveComparison(RecursiveComparisonConfiguration recursiveComparisonConfiguration)
Same as
usingRecursiveComparison() but allows to specify your own RecursiveComparisonConfiguration. |
SELF |
withFailMessage(String newErrorMessage,
Object... args)
Alternative method for
AbstractAssert.overridingErrorMessage(java.lang.String, java.lang.Object...) |
SELF |
withThreadDumpOnError()
In case of an assertion error, a thread dump will be printed to
System.err. |
doesNotReturn, extracting, extracting, extracting, extracting, extracting, extracting, extractingForProxy, getComparatorsByType, hasAllNullFieldsOrProperties, hasAllNullFieldsOrPropertiesExcept, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, hasOnlyFields, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, newObjectAssert, returns, usingComparatorForFields, usingComparatorForTypeareEqual, asInstanceOf, asList, assertionError, asString, descriptionText, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, hashCode, hasSameHashCodeAs, inBinary, inHexadecimal, isElementOfCustomAssert, isInstanceOfSatisfying, isNull, matches, matches, newListAssertInstance, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, withFailMessage, withRepresentationclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitaspublic SELF allSatisfy(BiConsumer<? super K,? super V> entryRequirements)
entryRequirements .
Example:
Map<TolkienCharacter, Ring> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(galadriel, nenya);
elvesRingBearers.put(gandalf, narya);
elvesRingBearers.put(elrond, vilya);
// this assertion succeeds:
assertThat(elvesRingBearers).allSatisfy((character, ring) -> {
assertThat(character.getRace()).isIn(ELF, MAIA);
assertThat(ring).isIn(nenya, narya, vilya);
});
// this assertion fails as Gandalf is a maia and not an elf:
assertThat(elvesRingBearers).allSatisfy((character, ring) -> {
assertThat(character.getRace()).isEqualTo(ELF);
assertThat(ring).isIn(nenya, narya, vilya);
});If the actual map is empty, this assertion succeeds as there is nothing to check.
entryRequirements - the given requirements that each entry must satisfy.this assertion object.NullPointerException - if the given entryRequirements BiConsumer is null.AssertionError - if the actual map is null.AssertionError - if one or more entries don't satisfy the given requirements.public SELF anySatisfy(BiConsumer<? super K,? super V> entryRequirements)
entryRequirements .
Example:
Map<TolkienCharacter, Ring> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(galadriel, nenya);
elvesRingBearers.put(gandalf, narya);
elvesRingBearers.put(elrond, vilya);
// this assertion succeeds as gandalf is a maia wearing narya:
assertThat(elvesRingBearers).anySatisfy((character, ring) -> {
assertThat(character.getRace()).isEqualTo(MAIA);
assertThat(ring).isEqualTo(narya);
});
// this assertion fails, gandalf is a maia but he does not wear the One Ring:
assertThat(elvesRingBearers).anySatisfy((character, ring) -> {
assertThat(character.getRace()).isIn(MAIA, HOBBIT);
assertThat(ring).isEqualTo(oneRing);
});entryRequirements - the given requirements that at least one entry must satisfy.this assertion object.NullPointerException - if the given entryRequirements BiConsumer is null.AssertionError - if the actual map is null.AssertionError - if no entries satisfy the given requirements.public SELF noneSatisfy(BiConsumer<? super K,? super V> entryRequirements)
entryRequirements .
Example:
Map<TolkienCharacter, Ring> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(galadriel, nenya);
elvesRingBearers.put(gandalf, narya);
elvesRingBearers.put(elrond, vilya);
// this assertion succeeds:
assertThat(elvesRingBearers).noneSatisfy((character, ring) -> {
assertThat(character.getRace()).isIn(HOBBIT, DWARF);M
assertThat(ring).isIn(nenya, narya, vilya);
});
// this assertion fails as Gandalf is a maia.
assertThat(elvesRingBearers).noneSatisfy((character, ring) -> {
assertThat(character.getRace()).isEqualTo(MAIA);
assertThat(ring).isIn(nenya, narya, vilya);
});If the actual map is empty, this assertion succeeds as there is nothing to check.
entryRequirements - the given requirements that each entry must not satisfy.this assertion object.NullPointerException - if the given entryRequirements BiConsumer is null.AssertionError - if the actual map is null.AssertionError - if one or more entries satisfies the given requirements.public void isNullOrEmpty()
Map is null or empty.
Example:
// assertions will pass
Map<Integer, String> map = null;
assertThat(map).isNullOrEmpty();
assertThat(new HashMap()).isNullOrEmpty();
// assertion will fail
Map<String, String> keyToValue = new HashMap();
keyToValue.put("key", "value");
assertThat(keyToValue).isNullOrEmpty()isNullOrEmpty in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>AssertionError - if the Map is not null or not empty.public void isEmpty()
Map is empty.
Example:
// assertion will pass
assertThat(new HashMap()).isEmpty();
// assertion will fail
Map<String, String> map = new HashMap();
map.put("key", "value");
assertThat(map).isEmpty();isEmpty in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>AssertionError - if the Map of values is not empty.public SELF isNotEmpty()
Map is not empty.
Example:
Map<String, String> map = new HashMap();
map.put("key", "value");
// assertion will pass
assertThat(map).isNotEmpty();
// assertion will fail
assertThat(new HashMap()).isNotEmpty();isNotEmpty in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>this assertion object.AssertionError - if the Map is empty.public SELF hasSize(int expected)
Map is equal to the given one.
Example:
Map<String, String> map = new HashMap();
map.put("key", "value");
// assertion will pass
assertThat(map).hasSize(1);
// assertions will fail
assertThat(map).hasSize(0);
assertThat(map).hasSize(2);hasSize in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>expected - the expected number of values in the Map.this assertion object.AssertionError - if the number of values of the Map is not equal to the given one.public SELF hasSizeGreaterThan(int boundary)
Map is greater than the boundary.
Example:
Map<String, String> map = new HashMap();
map.put("key", "value");
map.put("key2", "value2");
// assertion will pass
assertThat(map).hasSizeGreaterThan(1);
// assertions will fail
assertThat(map).hasSizeGreaterThan(3);hasSizeGreaterThan in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>boundary - the given value to compare the size of actual to.this assertion object.AssertionError - if the number of values of the Map is not greater than the boundary.public SELF hasSizeGreaterThanOrEqualTo(int boundary)
Map is greater than or equal to the boundary.
Example:
Map<String, String> map = new HashMap();
map.put("key", "value");
map.put("key2", "value2");
// assertions will pass
assertThat(map).hasSizeGreaterThanOrEqualTo(1)
.hasSizeGreaterThanOrEqualTo(2);
// assertions will fail
assertThat(map).hasSizeGreaterThanOrEqualTo(3);
assertThat(map).hasSizeGreaterThanOrEqualTo(5);hasSizeGreaterThanOrEqualTo in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>boundary - the given value to compare the size of actual to.this assertion object.AssertionError - if the number of values of the Map is not greater than or equal to the boundary.public SELF hasSizeLessThan(int boundary)
Map is less than the boundary.
Example:
Map<String, String> map = new HashMap();
map.put("key", "value");
map.put("key2", "value2");
// assertion will pass
assertThat(map).hasSizeLessThan(3);
// assertions will fail
assertThat(map).hasSizeLessThan(1);
assertThat(map).hasSizeLessThan(2);hasSizeLessThan in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>boundary - the given value to compare the size of actual to.this assertion object.AssertionError - if the number of values of the Map is not less than the boundary.public SELF hasSizeLessThanOrEqualTo(int boundary)
Map is less than or equal to the boundary.
Example:
Map<String, String> map = new HashMap();
map.put("key", "value");
map.put("key2", "value2");
// assertions will pass
assertThat(map).hasSizeLessThanOrEqualTo(2)
.hasSizeLessThanOrEqualTo(3);
// assertions will fail
assertThat(map).hasSizeLessThanOrEqualTo(0);
assertThat(map).hasSizeLessThanOrEqualTo(1);hasSizeLessThanOrEqualTo in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>boundary - the given value to compare the size of actual to.this assertion object.AssertionError - if the number of values of the Map is not less than the boundary.public SELF hasSizeBetween(int lowerBoundary, int higherBoundary)
Map is between the given boundaries (inclusive).
Example:
Map<String, String> map = new HashMap();
map.put("key", "value");
map.put("key2", "value2");
// assertions will pass
assertThat(map).hasSizeBetween(1, 3)
.hasSizeBetween(2, 2);
// assertions will fail
assertThat(map).hasSizeBetween(3, 4);hasSizeBetween in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>lowerBoundary - the lower boundary compared to which actual size should be greater than or equal to.higherBoundary - the higher boundary compared to which actual size should be less than or equal to.this assertion object.AssertionError - if the number of values of the Map is not between the boundaries.public SELF hasSameSizeAs(Object other)
Parameter is declared as Object to accept both Object[] and primitive arrays (e.g. int[]).
Example:
int[] oneTwoThree = {1, 2, 3};
Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(nenya, galadriel);
elvesRingBearers.put(narya, gandalf);
elvesRingBearers.put(vilya, elrond);
// assertion will pass
assertThat(elvesRingBearers).hasSameSizeAs(oneTwoThree);
// assertions will fail
assertThat(elvesRingBearers).hasSameSizeAs(new int[] {1});
assertThat(keyToValue).hasSameSizeAs(new char[] {'a', 'b', 'c', 'd'});hasSameSizeAs in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>other - the array to compare size with actual group.this assertion object.AssertionError - if the actual group is null.AssertionError - if the array parameter is null or is not a true array.AssertionError - if actual group and given array don't have the same size.public SELF hasSameSizeAs(Iterable<?> other)
Iterable.
Examples:
Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(nenya, galadriel);
elvesRingBearers.put(narya, gandalf);
elvesRingBearers.put(vilya, elrond);
// assertion will pass
assertThat(elvesRingBearers).hasSameSizeAs(Array.asList(vilya, nenya, narya));
// assertions will fail
assertThat(elvesRingBearers).hasSameSizeAs(Array.asList(1));
assertThat(keyToValue).hasSameSizeAs(Array.asList('a', 'b', 'c', 'd'));hasSameSizeAs in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>other - the Iterable to compare size with actual group.this assertion object.AssertionError - if the actual map is null.AssertionError - if the other Iterable is null.AssertionError - if the actual map and the given Iterable don't have the same sizepublic SELF hasSameSizeAs(Map<?,?> other)
Map.
Examples:
import static com.google.common.collect.ImmutableMap.of;
Map<Ring, TolkienCharacter> ringBearers = ImmutableMap.of(nenya, galadriel,
narya, gandalf,
vilya, elrond,
oneRing, frodo);
// assertion succeeds:
assertThat(ringBearers).hasSameSizeAs(ImmutableMap.of(oneRing, frodo,
narya, gandalf,
nenya, galadriel,
vilya, elrond));
// assertions fails:
assertThat(ringBearers).hasSameSizeAs(Collections.emptyMap());
assertThat(ringBearers).hasSameSizeAs(ImmutableMap.of(nenya, galadriel,
narya, gandalf,
vilya, elrond));other - the Map to compare size with actual mapthis assertion objectNullPointerException - if the other Map is nullAssertionError - if the actual map is nullAssertionError - if the actual map and the given Map don't have the same size@SafeVarargs public final SELF contains(Map.Entry<? extends K,? extends V>... entries)
This assertion succeeds if both actual map and given entries are empty.
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertions will pass
assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel));
assertThat(emptyMap).contains();
// assertions will fail
assertThat(ringBearers).contains(entry(oneRing, sauron));
assertThat(ringBearers).contains(entry(oneRing, sauron), entry(oneRing, aragorn));
assertThat(ringBearers).contains(entry(narya, gandalf), entry(oneRing, sauron));entries - the given entries.this assertion object.NullPointerException - if the given argument is null.NullPointerException - if any of the entries in the given array is null.AssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given entries.@SafeVarargs public final SELF containsAnyOf(Map.Entry<? extends K,? extends V>... entries)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertions will pass
assertThat(ringBearers).containsAnyOf(entry(oneRing, frodo), entry(oneRing, sauron));
assertThat(emptyMap).containsAnyOf();
// assertion will fail
assertThat(ringBearers).containsAnyOf(entry(oneRing, gandalf), entry(oneRing, aragorn));entries - the given entries.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.NullPointerException - if any of the entries in the given array is null.AssertionError - if the actual map is null.AssertionError - if the actual map does not contain any of the given entries.protected SELF containsAnyOfForProxy(Map.Entry<? extends K,? extends V>[] entries)
public SELF containsAllEntriesOf(Map<? extends K,? extends V> other)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(nenya, galadriel);
elvesRingBearers.put(narya, gandalf);
elvesRingBearers.put(vilya, elrond);
// assertions succeed
assertThat(ringBearers).containsAllEntriesOf(elvesRingBearers);
assertThat(ringBearers).containsAllEntriesOf(emptyMap);
// assertion fails
assertThat(elvesRingBearers).containsAllEntriesOf(ringBearers);other - the map with the given entries.this assertion object.NullPointerException - if the given argument is null.NullPointerException - if any of the entries in the given map is null.AssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given entries.public SELF containsExactlyEntriesOf(Map<? extends K,? extends V> map)
containsExactly(Map.Entry[]) but handles the conversion of Map.entrySet() to array.
Verifies that the actual map contains only the entries of the given map and nothing else, in order.
This assertion should only be used with maps that have a consistent iteration order (i.e. don't use it with
HashMap, prefer containsExactlyInAnyOrderEntriesOf(java.util.Map) in that case).
Examples:
// newLinkedHashMap builds a Map with iteration order corresponding to the insertion order
Map<Ring, TolkienCharacter> ringBearers = newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf));
// assertion will pass
assertThat(ringBearers).containsExactlyEntriesOf(newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf)));
// assertion will fail as actual and expected order differ
assertThat(ringBearers).containsExactlyEntriesOf(newLinkedHashMap(entry(nenya, galadriel),
entry(narya, gandalf),
entry(oneRing, frodo)));
// assertion will fail as actual and expected have different sizes
assertThat(ringBearers).containsExactlyEntriesOf(newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf),
entry(narya, gandalf)));map - the given Map with the expected entries to be found in actual.this assertions objectNullPointerException - if the given map is null.AssertionError - if the actual map is null.IllegalArgumentException - if the given map is empty.AssertionError - if the actual map does not contain the entries of the given map with same order, i.e
the actual map contains some or none of the entries of the given map, or the actual map contains more
entries than the entries of the given map or entries are the same but the order is not.public SELF containsExactlyInAnyOrderEntriesOf(Map<? extends K,? extends V> map)
containsOnly(Map.Entry[]) but handles the conversion of Map.entrySet() to array.
Verifies that the actual map contains only the given entries and nothing else, in any order.
Examples:
// newLinkedHashMap builds a Map with iteration order corresponding to the insertion order
Map<Ring, TolkienCharacter> ringBearers = newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf));
// assertion will pass
assertThat(ringBearers).containsExactlyInAnyOrderEntriesOf(newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf)));
// assertion will pass although actual and expected order differ
assertThat(ringBearers).containsExactlyInAnyOrderEntriesOf(newLinkedHashMap(entry(nenya, galadriel),
entry(narya, gandalf),
entry(oneRing, frodo)));
// assertion will fail as actual does not contain all expected entries
assertThat(ringBearers).containsExactlyInAnyOrderEntriesOf(newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(vilya, elrond)));
// assertion will fail as actual and expected have different sizes
assertThat(ringBearers).containsExactlyInAnyOrderEntriesOf(newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf),
entry(narya, gandalf)));map - the given Map with the expected entries to be found in actual.this assertions objectNullPointerException - if the given map is null.AssertionError - if the actual map is null.IllegalArgumentException - if the given map is empty.AssertionError - if the actual map does not contain the entries of the given map, i.e the actual map contains
some or none of the entries of the given map, or the actual map contains more entries than the entries of
the given map.public SELF containsEntry(K key, V value)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertions will pass
assertThat(ringBearers).containsEntry(oneRing, frodo).containsEntry(nenya, galadriel);
// assertion will fail
assertThat(ringBearers).containsEntry(oneRing, sauron);key - the given key to check.value - the given value to check.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.NullPointerException - if any of the entries in the given array is null.AssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given entries.public SELF hasEntrySatisfying(K key, Condition<? super V> valueCondition)
key that satisfies the given valueCondition.
Example:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
Condition<TolkienCharacter> elfBearer = new Condition<>("an elf bearer") {
public boolean matches(TolkienCharacter character) {
return character.getRace() == ELF;
}
};
// this assertion will pass
assertThat(ringBearers).hasEntrySatisfying(nenya, elfBearer);
// this assertion will fail
assertThat(ringBearers).hasEntrySatisfying(oneRing, elfBearer);key - he given key to check.valueCondition - the given condition for check value.this assertion object.NullPointerException - if the given values is null.AssertionError - if the actual map is null.AssertionError - if the actual map not contains the given key.AssertionError - if the actual map contains the given key, but value not match the given valueCondition.public SELF hasEntrySatisfying(K key, Consumer<? super V> valueRequirements)
key that satisfy given valueRequirements.
Example:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// this assertion will pass
assertThat(ringBearers).hasEntrySatisfying(nenya, character -> {
assertThat(character.getName()).contains("driel");
assertThat(character.getRace()).isEqualTo(ELF);
});
// this assertion will fail
assertThat(ringBearers).hasEntrySatisfying(oneRing, character -> {
assertThat(character.getRace()).isEqualTo(ELF);
});key - he given key to check.valueRequirements - the given requirements for check value.this assertion object.NullPointerException - if the given values is null.AssertionError - if the actual map is null.AssertionError - if the actual map not contains the given key.AssertionError - if the actual map contains the given key, but value not pass the given valueRequirements.public SELF hasEntrySatisfying(Condition<? super Map.Entry<K,V>> entryCondition)
entryCondition.
Example:
Map<TolkienCharacter, Ring> ringBearers = new HashMap<>();
ringBearers.put(galadriel, nenya);
ringBearers.put(gandalf, narya);
ringBearers.put(elrond, vilya);
ringBearers.put(frodo, oneRing);
Condition<Map.Entry<TolkienCharacter, Ring>> oneRingManBearer =
new Condition<Map.Entry<TolkienCharacter, Ring>>("One ring man bearer") {
public boolean matches(Map.Entry<TolkienCharacter, Ring> entry) {
return entry.getKey().getRace() == MAN && entry.getValue() == oneRing;
}
};
// assertion will fail
assertThat(ringBearers).hasEntrySatisfying(oneRingManBearer);
ringBearers.put(isildur, oneRing);
// now assertion will pass
assertThat(ringBearers).hasEntrySatisfying(oneRingManBearer);entryCondition - the condition for searching entry.this assertion object.NullPointerException - if the given condition is null.AssertionError - if the actual map is null.AssertionError - if there is no entry matching given entryCondition.public SELF hasEntrySatisfying(Condition<? super K> keyCondition, Condition<? super V> valueCondition)
keyCondition
and a value satisfying the given valueCondition.
Example:
Map<TolkienCharacter, Ring> ringBearers = new HashMap<>();
ringBearers.put(galadriel, nenya);
ringBearers.put(gandalf, narya);
ringBearers.put(elrond, vilya);
ringBearers.put(frodo, oneRing);
Condition<TolkienCharacter> isMan = new Condition<TolkienCharacter>("is man") {
public boolean matches(TolkienCharacter tolkienCharacter) {
return tolkienCharacter.getRace() == MAN;
}
};
Condition<Ring> oneRingBearer = new Condition<Ring>("One ring bearer") {
public boolean matches(Ring ring) {
return ring == oneRing;
}
};
// assertion will fail
assertThat(ringBearers).hasEntrySatisfying(isMan, oneRingBearer);
ringBearers.put(isildur, oneRing);
// now assertion will pass
assertThat(ringBearers).hasEntrySatisfying(isMan, oneRingBearer);keyCondition - the condition to be matched by the entry's key.valueCondition - the condition to be matched by the entry's value.this assertion object.NullPointerException - if any of the given conditions is null.AssertionError - if the actual map is null.AssertionError - if there is no entry with a key matching keyCondition and a value matching valueCondition.public SELF hasKeySatisfying(Condition<? super K> keyCondition)
keyCondition.
Example:
Map<TolkienCharacter, Ring> ringBearers = new HashMap<>();
ringBearers.put(galadriel, nenya);
ringBearers.put(gandalf, narya);
ringBearers.put(elrond, vilya);
ringBearers.put(frodo, oneRing);
Condition<TolkienCharacter> isElf = new Condition<TolkienCharacter>("is elf") {
public boolean matches(TolkienCharacter tolkienCharacter) {
return tolkienCharacter.getRace() == ELF;
}
};
Condition<TolkienCharacter> isOrc = new Condition<TolkienCharacter>("is orc") {
public boolean matches(TolkienCharacter tolkienCharacter) {
return tolkienCharacter.getRace() == ORC;
}
};
// assertion will pass
assertThat(ringBearers).hasKeySatisfying(isElf);
// assertion will fail
assertThat(ringBearers).hasKeySatisfying(isOrc);keyCondition - the condition to be matched by the entry's key.this assertion object.NullPointerException - if the given condition is null.AssertionError - if the actual map is null.AssertionError - if there is no key matching the given keyCondition.public SELF hasValueSatisfying(Condition<? super V> valueCondition)
valueCondition.
Example:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
Condition<TolkienCharacter> isElf = new Condition<TolkienCharacter>("is elf") {
public boolean matches(TolkienCharacter tolkienCharacter) {
return tolkienCharacter.getRace() == ELF;
}
};
Condition<TolkienCharacter> isOrc = new Condition<TolkienCharacter>("is orc") {
public boolean matches(TolkienCharacter tolkienCharacter) {
return tolkienCharacter.getRace() == ORC;
}
};
// assertion will pass
assertThat(ringBearers).hasValueSatisfying(isElf);
// assertion will fail
assertThat(ringBearers).hasValueSatisfying(isOrc);valueCondition - the condition to be matched by the entry's value.this assertion object.NullPointerException - if the given condition is null.AssertionError - if the actual map is null.AssertionError - if there is no value matching the given valueCondition.@SafeVarargs public final SELF doesNotContain(Map.Entry<? extends K,? extends V>... entries)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertion will pass
assertThat(ringBearers).doesNotContain(entry(oneRing, aragorn), entry(oneRing, sauron));
// assertions will fail
assertThat(ringBearers).doesNotContain(entry(oneRing, frodo));
assertThat(ringBearers).doesNotContain(entry(oneRing, frodo), entry(oneRing, aragorn));entries - the given entries.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual map is null.AssertionError - if the actual map contains any of the given entries.protected SELF doesNotContainForProxy(Map.Entry<? extends K,? extends V>[] entries)
public SELF doesNotContainEntry(K key, V value)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertion will pass
assertThat(ringBearers).doesNotContainEntry(oneRing, aragorn);
// assertion will fail
assertThat(ringBearers).doesNotContain(oneRing, frodo);key - key of the entry.value - value of the entry.this assertion object.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual map is null.AssertionError - if the actual map contains any of the given entries.public SELF containsKey(K key)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
// assertion will pass
assertThat(ringBearers).containsKey(vilya);
// assertion will fail
assertThat(ringBearers).containsKey(oneRing);key - the given keythis assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given key.@SafeVarargs public final SELF containsKeys(K... keys)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(oneRing, frodo);
// assertions will pass
assertThat(ringBearers).containsKeys(nenya, oneRing);
// assertions will fail
assertThat(ringBearers).containsKeys(vilya);
assertThat(ringBearers).containsKeys(vilya, oneRing);keys - the given keysthis assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given key.IllegalArgumentException - if the given argument is an empty array.public SELF doesNotContainKey(K key)
Examples:
Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(nenya, galadriel);
elvesRingBearers.put(narya, gandalf);
elvesRingBearers.put(vilya, elrond);
// assertion will pass
assertThat(elvesRingBearers).doesNotContainKey(oneRing);
// assertion will fail
assertThat(elvesRingBearers).doesNotContainKey(vilya);key - the given keythis assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map contains the given key.@SafeVarargs public final SELF doesNotContainKeys(K... keys)
Examples:
Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
elvesRingBearers.put(nenya, galadriel);
elvesRingBearers.put(narya, gandalf);
elvesRingBearers.put(vilya, elrond);
// assertion will pass
assertThat(elvesRingBearers).doesNotContainKeys(oneRing, someManRing);
// assertions will fail
assertThat(elvesRingBearers).doesNotContainKeys(vilya, nenya);
assertThat(elvesRingBearers).doesNotContainKeys(vilya, oneRing);keys - the given keysthis assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map contains the given key.@SafeVarargs public final SELF containsOnlyKeys(K... keys)
The verification tries to honor the key comparison semantic of the underlying map implementation. The map under test has to be cloned to identify unexpected elements, but depending on the map implementation this may not always be possible. In case it is not possible, a regular map is used and the key comparison strategy may not be the same as the map under test.
Examples :
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertion will pass
assertThat(ringBearers).containsOnlyKeys(oneRing, nenya, narya, vilya);
// assertion will fail
assertThat(ringBearers).containsOnlyKeys(oneRing, nenya);keys - the given keys that should be in the actual map.this assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given keys, i.e. the actual map contains some or none
of the given keys, or the actual map contains more entries than the given ones.IllegalArgumentException - if the given argument is an empty array.public SELF containsOnlyKeys(Iterable<? extends K> keys)
The verification tries to honor the key comparison semantic of the underlying map implementation. The map under test has to be cloned to identify unexpected elements, but depending on the map implementation this may not always be possible. In case it is not possible, a regular map is used and the key comparison strategy may not be the same as the map under test.
Examples :
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertion will pass
assertThat(ringBearers).containsOnlyKeys(Arrays.asList(oneRing, nenya, narya, vilya));
// assertions will fail
assertThat(ringBearers).containsOnlyKeys(Arrays.asList(oneRing, nenya));
assertThat(ringBearers).containsOnlyKeys(Arrays.asList(oneRing, nenya, narya, vilya, nibelungRing));keys - the given keys that should be in the actual map.this assertions objectAssertionError - if the actual map is null or empty.AssertionError - if the actual map does not contain the given keys, i.e. the actual map contains some or none
of the given keys, or the actual map's keys contains keys not in the given ones.IllegalArgumentException - if the given argument is an empty array.public SELF containsValue(V value)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertion will pass
assertThat(ringBearers).containsValue(frodo);
// assertion will fail
assertThat(ringBearers).containsValue(sauron);value - the value to look for.this assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given value.@SafeVarargs public final SELF containsValues(V... values)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertion will pass
assertThat(ringBearers).containsValues(frodo, galadriel);
// assertions will fail
assertThat(ringBearers).containsValues(sauron, aragorn);
assertThat(ringBearers).containsValues(sauron, frodo);values - the values to look for in the actual map.this assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map does not contain the given values.public SELF doesNotContainValue(V value)
Examples:
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertion will pass
assertThat(ringBearers).doesNotContainValue(aragorn);
// assertion will fail
assertThat(ringBearers).doesNotContainValue(frodo);value - the value that should not be in actual map.this assertions objectAssertionError - if the actual map is null.AssertionError - if the actual map contains the given value.@SafeVarargs public final SELF containsOnly(Map.Entry<? extends K,? extends V>... entries)
The verification tries to honor the key comparison semantic of the underlying map implementation. The map under test has to be cloned to identify unexpected elements, but depending on the map implementation this may not always be possible. In case it is not possible, a regular map is used and the key comparison strategy may not be the same as the map under test.
Examples :
Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
ringBearers.put(nenya, galadriel);
ringBearers.put(narya, gandalf);
ringBearers.put(vilya, elrond);
ringBearers.put(oneRing, frodo);
// assertions will pass
assertThat(ringBearers).containsOnly(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf),
entry(vilya, elrond));
assertThat(Collections.emptyMap()).containsOnly();
// assertion will fail
assertThat(ringBearers).containsOnly(entry(oneRing, frodo), entry(nenya, galadriel));entries - the entries that should be in the actual map.this assertions objectAssertionError - if the actual map is null.NullPointerException - if the given argument is null.IllegalArgumentException - if the given argument is an empty array.AssertionError - if the actual map does not contain the given entries, i.e. the actual map contains some or
none of the given entries, or the actual map contains more entries than the given ones.protected SELF containsOnlyForProxy(Map.Entry<? extends K,? extends V>[] entries)
@SafeVarargs public final SELF containsExactly(Map.Entry<? extends K,? extends V>... entries)
HashMap, prefer containsOnly(java.util.Map.Entry...) in that case).
Examples:
// newLinkedHashMap builds a Map with iteration order corresponding to the insertion order
Map<Ring, TolkienCharacter> ringBearers = newLinkedHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf));
// assertions will pass
assertThat(ringBearers).containsExactly(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf));
assertThat(Collections.emptyMap()).containsExactly();
// assertion will fail as actual and expected order differ
assertThat(ringBearers).containsExactly(entry(nenya, galadriel),
entry(narya, gandalf),
entry(oneRing, frodo));entries - the given entries.this assertions objectNullPointerException - if the given entries array is null.AssertionError - if the actual map is null.IllegalArgumentException - if the given entries array is empty.AssertionError - if the actual map does not contain the given entries with same order, i.e. the actual map
contains some or none of the given entries, or the actual map contains more entries than the given ones
or entries are the same but the order is not.protected SELF containsExactlyForProxy(Map.Entry<? extends K,? extends V>[] entries)
@Deprecated public SELF usingElementComparator(Comparator<? super Map.Entry<? extends K,? extends V>> customComparator)
usingElementComparator in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>customComparator - the comparator to use for incoming assertion checks.this assertion object.UnsupportedOperationException - if this method is called.@Deprecated public SELF usingDefaultElementComparator()
usingDefaultElementComparator in interface EnumerableAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,Map.Entry<? extends K,? extends V>>this assertion object.UnsupportedOperationException - if this method is called.public SELF as(String description, Object... args)
DescriptableYou must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
The description follows String.format(String, Object...) syntax.
Example :
try {
// set an incorrect age to Mr Frodo which is really 33 years old.
frodo.setAge(50);
// specify a test description (call as() before the assertion !), it supports String format syntax.
assertThat(frodo.getAge()).as("check %s's age", frodo.getName()).isEqualTo(33);
} catch (AssertionError e) {
assertThat(e).hasMessage("[check Frodo's age]\n
expected: 33\n
but was: 50");
}as in interface Descriptable<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>>as in class AbstractObjectAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>description - the new description to set.args - optional parameter if description is a format String.this object.Descriptable.describedAs(String, Object...)public SELF as(Description description)
DescriptableYou must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing
users to pass their own implementation of a description. For example, a description that creates its value lazily,
only when an assertion failure occurs.
as in interface Descriptable<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>>as in class AbstractObjectAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>description - the new description to set.this object.Descriptable.describedAs(Description)public SELF describedAs(Description description)
AbstractAssertYou must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing
users to pass their own implementation of a description. For example, a description that creates its value lazily,
only when an assertion failure occurs.
describedAs in interface Descriptable<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>>describedAs in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>description - the new description to set.this object.public SELF describedAs(String description, Object... args)
DescriptableYou must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
Alias for Descriptable.as(String, Object...)
describedAs in interface Descriptable<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>>description - the new description to set.args - optional parameter if description is a format String.this object.public SELF doesNotHave(Condition<? super ACTUAL> condition)
AbstractAssertExtensionPoints.isNot(Condition)doesNotHave in interface ExtensionPoints<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>doesNotHave in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>condition - the given condition.this ExtensionPoints object.ExtensionPoints.isNot(Condition)public SELF doesNotHaveSameClassAs(Object other)
AbstractAssertExample:
// 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>());doesNotHaveSameClassAs in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>doesNotHaveSameClassAs in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>other - the object to check type against.public SELF has(Condition<? super ACTUAL> condition)
AbstractAssertExtensionPoints.is(Condition)has in interface ExtensionPoints<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>has in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>condition - the given condition.this ExtensionPoints object.ExtensionPoints.is(Condition)public SELF hasSameClassAs(Object other)
AbstractAssertExample:
// 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>());hasSameClassAs in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>hasSameClassAs in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>other - the object to check type against.public SELF hasToString(String expectedToString)
AbstractAssertactual.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");hasToString in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>hasToString in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>expectedToString - the expected String description of actual.public SELF is(Condition<? super ACTUAL> condition)
AbstractAssertExtensionPoints.has(Condition)is in interface ExtensionPoints<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>is in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>condition - the given condition.this ExtensionPoints object.ExtensionPoints.has(Condition)public SELF isEqualTo(Object expected)
AbstractAssertExample:
// 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);isEqualTo in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isEqualTo in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>expected - the given value to compare the actual value to.this assertion object.public SELF isExactlyInstanceOf(Class<?> type)
AbstractAssertExample:
// 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);isExactlyInstanceOf in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isExactlyInstanceOf in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>type - the type to check the actual value against.public SELF isIn(Iterable<?> values)
AbstractAssertThis 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());isIn in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isIn in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>values - the given iterable to search the actual value in.this assertion object.public SELF isIn(Object... values)
AbstractAssertThis 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]);isIn in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isIn in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>values - the given array to search the actual value in.this assertion object.public SELF isInstanceOf(Class<?> type)
AbstractAssertExample:
// 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);isInstanceOf in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isInstanceOf in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>type - the type to check the actual value against.public SELF isInstanceOfAny(Class<?>... types)
AbstractAssertExample:
// 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);isInstanceOfAny in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isInstanceOfAny in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>types - the types to check the actual value against.public SELF isNot(Condition<? super ACTUAL> condition)
AbstractAssertExtensionPoints.doesNotHave(Condition)isNot in interface ExtensionPoints<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNot in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>condition - the given condition.this ExtensionPoints object.ExtensionPoints.isNot(Condition)public SELF isNotEqualTo(Object other)
AbstractAssertExample:
// 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>());isNotEqualTo in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotEqualTo in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>other - the given value to compare the actual value to.this assertion object.public SELF isNotExactlyInstanceOf(Class<?> type)
AbstractAssertExample:
// 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);isNotExactlyInstanceOf in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotExactlyInstanceOf in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>type - the type to check the actual value against.public SELF isNotIn(Iterable<?> values)
AbstractAssertThis 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);isNotIn in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotIn in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>values - the given iterable to search the actual value in.this assertion object.public SELF isNotIn(Object... values)
AbstractAssertThis 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);isNotIn in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotIn in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>values - the given array to search the actual value in.this assertion object.public SELF isNotInstanceOf(Class<?> type)
AbstractAssertExample:
// 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);isNotInstanceOf in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotInstanceOf in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>type - the type to check the actual value against.public SELF isNotInstanceOfAny(Class<?>... types)
AbstractAssertExample:
// 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);isNotInstanceOfAny in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotInstanceOfAny in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>types - the types to check the actual value against.public SELF isNotOfAnyClassIn(Class<?>... types)
AbstractAssertExample:
// 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);isNotOfAnyClassIn in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotOfAnyClassIn in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>types - the types to check the actual value against.public SELF isNotNull()
AbstractAssertnull.
Example:
// assertions succeed
assertThat("abc").isNotNull();
assertThat(new HashMap<String, Integer>()).isNotNull();
// assertions fails
String value = null;
assertThat(value).isNotNull();public SELF isNotSameAs(Object other)
AbstractAssertExample:
// Name is a class with first and last fields, two Names are equals if both first and last are equals.
Name tyrion = new Name("Tyrion", "Lannister");
Name alias = tyrion;
Name clone = new Name("Tyrion", "Lannister");
// assertions succeed:
assertThat(clone).isNotSameAs(tyrion)
.isEqualTo(tyrion);
// assertion fails:
assertThat(alias).isNotSameAs(tyrion);isNotSameAs in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isNotSameAs in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>other - the given value to compare the actual value to.this assertion object.public SELF isOfAnyClassIn(Class<?>... types)
AbstractAssertExample:
// 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);isOfAnyClassIn in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isOfAnyClassIn in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>types - the types to check the actual value against.public SELF isSameAs(Object expected)
AbstractAssertExample:
// 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);isSameAs in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>isSameAs in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>expected - the given value to compare the actual value to.this assertion object.public SELF overridingErrorMessage(String newErrorMessage, Object... args)
AbstractAssertYou 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();overridingErrorMessage in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>newErrorMessage - the error message that will replace the default one provided by Assertj.args - the args used to fill error message as in String.format(String, Object...).public SELF usingDefaultComparator()
AbstractAssert
This method should be used to disable a custom comparison strategy set by calling usingComparator.
usingDefaultComparator in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>usingDefaultComparator in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>this assertion object.public SELF usingComparator(Comparator<? super ACTUAL> customComparator)
AbstractAssertThe 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);usingComparator in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>usingComparator in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>customComparator - the comparator to use for the incoming assertion checks.this assertion object.public SELF usingComparator(Comparator<? super ACTUAL> customComparator, String customComparatorDescription)
AbstractAssertThe 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);usingComparator in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>usingComparator in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>customComparator - the comparator to use for the incoming assertion checks.customComparatorDescription - comparator description to be used in assertion error messagesthis assertion object.public SELF withFailMessage(String newErrorMessage, Object... args)
AbstractAssertAbstractAssert.overridingErrorMessage(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();withFailMessage in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>newErrorMessage - the error message that will replace the default one provided by Assertj.args - the args used to fill error message as in String.format(String, Object...).public SELF withThreadDumpOnError()
AbstractAssertSystem.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)withThreadDumpOnError in interface Assert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>withThreadDumpOnError in class AbstractAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>public AbstractMapSizeAssert<SELF,ACTUAL,K,V> size()
Assert object that allows performing assertions on the size of the Map under test.
Once this method is called, the object under test is no longer the Map but its size,
to perform assertions on the Map, call AbstractMapSizeAssert.returnToMap().
Examples:
Map<Ring, TolkienCharacter> ringBearers = newHashMap(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf));
// assertion will pass:
assertThat(ringBearers).size().isGreaterThan(1)
.isLessThanOrEqualTo(3)
returnToMap().contains(entry(oneRing, frodo),
entry(nenya, galadriel),
entry(narya, gandalf));
// assertion will fail:
assertThat(ringBearers).size().isGreaterThan(5);AbstractMapSizeAssert to allow assertions on the number of key-value mappings in this mapNullPointerException - if the given map is null.@Deprecated public AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> extracting(Object... keys)
extractingByKeys(Object[]) insteadFor example, if you specify "id", "name" and "email" keys then the array will contain the map values for these keys, you can then perform array assertions on the extracted values.
If a given key is not present in the map under test, a null value is extracted.
Example:
Map<String, Object> map = new HashMap<>();
map.put("name", "kawhi");
map.put("age", 25);
assertThat(map).extracting("name", "age")
.contains("kawhi", 25);Note that the order of extracted keys value is consistent with the iteration order of the array under test.
Nested keys are not yet supported, passing "name.first" won't get a value for "name" and then try to extract "first" from the previously extracted value, instead it will simply look for a value under "name.first" key.
keys - the keys used to get values from the map under test@SafeVarargs public final AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> extractingByKeys(K... keys)
For example, if you specify "id", "name" and "email" keys then the array will contain the map values for these keys, you can then perform array assertions on the extracted values.
If a given key is not present in the map under test, a null value is extracted.
Example:
Map<String, Object> map = new HashMap<>();
map.put("name", "kawhi");
map.put("age", 25);
assertThat(map).extractingByKeys("name", "age")
.contains("kawhi", 25);Note that:
keys - the keys used to get values from the map under testprotected AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> extractingByKeysForProxy(K[] keys)
@Deprecated public AbstractObjectAssert<?,?> extracting(Object key)
extractingByKey(Object) insteadFor example, if you specify "id" key, then the object under test will be the map value for this key.
If a given key is not present in the map under test, a null value is extracted.
Example:
Map<String, Object> map = new HashMap<>();
map.put("name", "kawhi");
assertThat(map).extracting("name")
.isEqualTo("kawhi");Nested keys are not yet supported, passing "name.first" won't get a value for "name" and then try to extract "first" from the previously extracted value, instead it will simply look for a value under "name.first" key.
key - the key used to get value from the map under testObjectAssert instance whose object under test is the extracted map valuepublic AbstractObjectAssert<?,V> extractingByKey(K key)
For example, if you specify "id" key, then the object under test will be the map value for this key.
If a given key is not present in the map under test, a null value is extracted.
Example:
Map<String, Object> map = new HashMap<>();
map.put("name", "kawhi");
assertThat(map).extractingByKey("name")
.isEqualTo("kawhi");key - the key used to get value from the map under testObjectAssert instance whose object under test is the extracted map valueextractingByKey(Object, InstanceOfAssertFactory)public <ASSERT extends AbstractAssert<?,?>> ASSERT extractingByKey(K key, InstanceOfAssertFactory<?,ASSERT> assertFactory)
For example, if you specify "id" key, then the object under test will be the map value for this key.
If a given key is not present in the map under test, the assertion will fail.
The assertFactory parameter allows to specify an InstanceOfAssertFactory, which is used to get the
assertions narrowed to the factory type.
Wrapping the given InstanceOfAssertFactory with Assertions.as(InstanceOfAssertFactory) makes the
assertion more readable.
Example:
Map<String, Object> map = new HashMap<>();
map.put("name", "kawhi");
assertThat(map).extractingByKey("name", as(InstanceOfAssertFactories.STRING))
.startsWith("kaw");Nested keys are not yet supported, passing "name.first" won't get a value for "name" and then try to extract "first" from the previously extracted value, instead it will simply look for a value under "name.first" key.
ASSERT - the type of the resulting Assertkey - the key used to get value from the map under testassertFactory - the factory which verifies the type and creates the new AssertAssert instance whose object under test is the extracted map valueNullPointerException - if the given factory is nullpublic AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> extractingFromEntries(Function<? super Map.Entry<K,V>,Object> extractor)
Function to extract a value from the Map's entries.
The extracted values are stored in a new list becoming the object under test.
Let's take a look at an example to make things clearer :
// Build a Map that associates family roles and name of the Simpson family
Map<String, CartoonCharacter> characters = new HashMap<>();
characters.put("dad", new CartoonCharacter("Homer"));
characters.put("mom", new CartoonCharacter("Marge"));
characters.put("girl", new CartoonCharacter("Lisa"));
characters.put("boy", new CartoonCharacter("Bart"));
assertThat(characters).extractingFromEntries(e -> e.getValue().getName())
.containsOnly("Homer", "Marge", "Lisa", "Bart");extractor - the extractor function to extract a value from an entry of the Map under test.@SafeVarargs public final AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> extractingFromEntries(Function<? super Map.Entry<K,V>,Object>... extractors)
Functions to extract values from the Map's entries.
The extracted values are stored in a new list composed of Tuples (a simple data structure containing the extracted values),
this new list becoming the object under test.
This method works as extractingFromEntries(java.util.function.Function) except
that it is designed to extract multiple values from the Map entries.
That's why here the new object under test is a List of Tuples.
The Tuple data corresponds to the extracted values from the Map's entries, for instance if you pass functions extracting the "id", "name" and "email" values then each Tuple data will be composed of an id, a name and an email extracted from the entry of the Map (the Tuple's data order is the same as the given functions order).
Let's take a look at an example to make things clearer :
// Build a Map that associates family roles and name of the Simpson family
Map<String, CartoonCharacter> characters = new HashMap<>();
characters.put("dad", new CartoonCharacter("Homer"));
characters.put("mom", new CartoonCharacter("Marge"));
characters.put("girl", new CartoonCharacter("Lisa"));
characters.put("boy", new CartoonCharacter("Bart"));
assertThat(characters).extractingFromEntries(e -> e.getKey(), e -> e.getValue().getName())
.containsOnly(tuple("dad", "Homer"),
tuple("mom", "Marge"),
tuple("girl", "Lisa"),
tuple("boy", "Bart"));HashSet, you won't be able to make any assumptions on the extracted values
order.extractors - the extractor functions to extract values from an entry of the Map under test.protected AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> extractingFromEntriesForProxy(Function<? super Map.Entry<K,V>,Object>[] extractors)
public AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> flatExtracting(String... keys)
If a given key is not present in the map under test, a null value is extracted.
If a given key value is not an Iterable or an array, it is simply extracted but (obviously) not flattened.
Example:
List<String> names = asList("Dave", "Jeff");
LinkedHashSet<String> jobs = newLinkedHashSet("Plumber", "Builder");
Iterable<String> cities = asList("Dover", "Boston", "Paris");
int[] ranks = { 1, 2, 3 };
Map<String, Object> map = new LinkedHashMap<>();
map.put("name", names);
map.put("job", jobs);
map.put("city", cities);
map.put("rank", ranks);
assertThat(map).flatExtracting("name","job","city", "rank")
.containsExactly("Dave", "Jeff",
"Plumber", "Builder",
"Dover", "Boston", "Paris",
1, 2, 3);
// the order of values in the resulting array is the order of map keys then key values:
assertThat(map).flatExtracting("city", "job", "name")
.containsExactly("Dover", "Boston", "Paris",
"Plumber", "Builder",
"Dave", "Jeff");
// contains exactly null twice (one for each unknown keys)
assertThat(map).flatExtracting("foo", "name", "bar")
.containsExactly(null, "Dave", "Jeff", null);
// if the key value is not an iterable/array, it will be simply extracted but not flattened.
map.put("year", 2017));
assertThat(map).flatExtracting("name","job","year")
.containsExactly("Dave", "Jeff", "Plumber", "Builder", "Dover", 2017);Note that the order of values in the resulting array is the order of the map keys iteration then key values.
keys - the keys used to get values from the map under testpublic RecursiveComparisonAssert<?> usingRecursiveComparison()
RecursiveComparisonAssert,
Example:
public class Person {
String name;
boolean hasPhd;
}
public class Doctor {
String name;
boolean hasPhd;
}
Doctor drSheldon = new Doctor("Sheldon Cooper", true);
Doctor drLeonard = new Doctor("Leonard Hofstadter", true);
Doctor drRaj = new Doctor("Raj Koothrappali", true);
Person sheldon = new Person("Sheldon Cooper", true);
Person leonard = new Person("Leonard Hofstadter", true);
Person raj = new Person("Raj Koothrappali", true);
Map<String, Doctor> doctors = mapOf(entry(drSheldon.name, drSheldon),
entry(drLeonard.name, drLeonard),
entry(drRaj.name, drRaj));
Map<String, Person> people = mapOf(entry(sheldon.name, sheldon),
entry(leonard.name, leonard),
entry(raj.name, raj));
// assertion succeeds as both maps contains equivalent items.
assertThat(doctors).usingRecursiveComparison()
.isEqualTo(people);
// assertion fails because leonard names are different.
leonard.setName("Leonard Ofstater");
assertThat(doctors).usingRecursiveComparison()
.isEqualTo(people);
The default recursive comparison behavior is configured as follows:
HashMap<Person> and a LinkedHashMap<PersonDto>.withStrictTypeChecking.java.lang.Double: DoubleComparator with precision of 1.0E-15java.lang.Float: FloatComparator with precision of 1.0E-6AbstractIterableAssert.usingComparatorForType(Comparator, Class) At the moment, only `isEqualTo` can be chained after this method but there are plans to provide assertions.
usingRecursiveComparison in class AbstractObjectAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>RecursiveComparisonAssert instanceRecursiveComparisonConfigurationpublic RecursiveComparisonAssert<?> usingRecursiveComparison(RecursiveComparisonConfiguration recursiveComparisonConfiguration)
usingRecursiveComparison() but allows to specify your own RecursiveComparisonConfiguration.usingRecursiveComparison in class AbstractObjectAssert<SELF extends AbstractMapAssert<SELF,ACTUAL,K,V>,ACTUAL extends Map<K,V>>recursiveComparisonConfiguration - the RecursiveComparisonConfiguration used in the chained isEqualTo assertion.RecursiveComparisonAssert instance built with the given RecursiveComparisonConfiguration.Copyright © 2025. All rights reserved.