com.google.common.truth

Class MapSubject.UsingCorrespondence<A,E>

java.lang.Object

com.google.common.truth.MapSubject.UsingCorrespondence<A,E>

Enclosing class:

MapSubject

public final class MapSubject.UsingCorrespondence<A,E>
extends Object

A partially specified check in which the actual values (i.e. the values of the Map under test) are compared to expected values using a Correspondence. The expected values are of type E. Call methods on this object to actually execute the check.

Note that keys will always be compared with regular object equality (Object.equals(java.lang.Object)).

Method Summary

Modifier and Type	Method and Description
Ordered	containsAtLeast(Object k0, E v0, Object... rest) Fails if the map does not contain at least the given set of keys mapping to values that correspond to the given values.
<K,V extends E> Ordered	containsAtLeastEntriesIn(Map<K,V> expectedMap) Fails if the map does not contain at least the keys in the given map, mapping to values that correspond to the values of the given map.
void	containsEntry(Object expectedKey, E expectedValue) Fails if the map does not contain an entry with the given key and a value that corresponds to the given value.
Ordered	containsExactly(Object k0, E v0, Object... rest) Fails if the map does not contain exactly the given set of keys mapping to values that correspond to the given values.
<K,V extends E> Ordered	containsExactlyEntriesIn(Map<K,V> expectedMap) Fails if the map does not contain exactly the keys in the given map, mapping to values that correspond to the values of the given map.
void	doesNotContainEntry(Object excludedKey, E excludedValue) Fails if the map contains an entry with the given key and a value that corresponds to the given value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

containsEntry

public void containsEntry(@NullableDecl
                          Object expectedKey,
                          @NullableDecl
                          E expectedValue)

Fails if the map does not contain an entry with the given key and a value that corresponds to the given value.

doesNotContainEntry

public void doesNotContainEntry(@NullableDecl
                                Object excludedKey,
                                @NullableDecl
                                E excludedValue)

Fails if the map contains an entry with the given key and a value that corresponds to the given value.

containsExactly

@CanIgnoreReturnValue
public Ordered containsExactly(@NullableDecl
                                                     Object k0,
                                                     @NullableDecl
                                                     E v0,
                                                     Object... rest)

Fails if the map does not contain exactly the given set of keys mapping to values that correspond to the given values.

The values must all be of type E, and a ClassCastException will be thrown if any other type is encountered.

Warning: the use of varargs means that we cannot guarantee an equal number of key/value pairs at compile time. Please make sure you provide varargs in key/value pairs!

containsAtLeast

@CanIgnoreReturnValue
public Ordered containsAtLeast(@NullableDecl
                                                     Object k0,
                                                     @NullableDecl
                                                     E v0,
                                                     Object... rest)

Fails if the map does not contain at least the given set of keys mapping to values that correspond to the given values.

The values must all be of type E, and a ClassCastException will be thrown if any other type is encountered.

Warning: the use of varargs means that we cannot guarantee an equal number of key/value pairs at compile time. Please make sure you provide varargs in key/value pairs!

containsExactlyEntriesIn

@CanIgnoreReturnValue
public <K,V extends E> Ordered containsExactlyEntriesIn(Map<K,V> expectedMap)

Fails if the map does not contain exactly the keys in the given map, mapping to values that correspond to the values of the given map.

containsAtLeastEntriesIn

@CanIgnoreReturnValue
public <K,V extends E> Ordered containsAtLeastEntriesIn(Map<K,V> expectedMap)

Fails if the map does not contain at least the keys in the given map, mapping to values that correspond to the values of the given map.