com.google.common.truth

Class MultimapSubject

java.lang.Object

com.google.common.truth.Subject<MultimapSubject,Multimap<?,?>>

com.google.common.truth.MultimapSubject

Direct Known Subclasses:

ListMultimapSubject, SetMultimapSubject

public class MultimapSubject
extends Subject<MultimapSubject,Multimap<?,?>>

Propositions for Multimap subjects.

Author:

Daniel Ploch, Kurt Alfred Kluever

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	MultimapSubject.UsingCorrespondence<A,E> A partially specified check in which the actual values (i.e.

Nested classes/interfaces inherited from class com.google.common.truth.Subject

Subject.Factory<SubjectT extends Subject<SubjectT,ActualT>,ActualT>

Method Summary

Modifier and Type	Method and Description
<A,E> MultimapSubject.UsingCorrespondence<A,E>	comparingValuesUsing(Correspondence<A,E> correspondence) Starts a method chain for a check in which the actual values (i.e.
void	containsEntry(Object key, Object value) Fails if the multimap does not contain the given entry.
Ordered	containsExactly() Fails if the multimap is not empty.
Ordered	containsExactly(Object k0, Object v0, Object... rest) Fails if the multimap does not contain exactly the given set of key/value pairs.
Ordered	containsExactlyEntriesIn(Multimap<?,?> expectedMultimap) Fails if the Multimap does not contain precisely the same entries as the argument Multimap.
void	containsKey(Object key) Fails if the multimap does not contain the given key.
void	doesNotContainEntry(Object key, Object value) Fails if the multimap contains the given entry.
void	doesNotContainKey(Object key) Fails if the multimap contains the given key.
void	hasSize(int expectedSize) Fails if the multimap does not have the given size.
void	isEmpty() Fails if the multimap is not empty.
void	isEqualTo(Object other) Fails if the subject is not equal to the given object.
void	isNotEmpty() Fails if the multimap is empty.
IterableSubject	valuesForKey(Object key) Returns a context-aware Subject for making assertions about the values for the given key within the Multimap.

Methods inherited from class com.google.common.truth.Subject

actual, actualAsString, actualCustomStringRepresentation, check, check, equals, fail, fail, fail, failComparing, failComparing, failWithActual, failWithActual, failWithBadResults, failWithCustomSubject, failWithoutActual, failWithoutActual, failWithoutSubject, failWithRawMessage, failWithRawMessageAndCause, getSubject, hashCode, ignoreCheck, internalCustomName, isAnyOf, isIn, isInstanceOf, isNoneOf, isNotEqualTo, isNotIn, isNotInstanceOf, isNotNull, isNotSameAs, isNull, isSameAs, named, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Method Detail

isEmpty

public void isEmpty()

Fails if the multimap is not empty.

isNotEmpty

public void isNotEmpty()

Fails if the multimap is empty.

hasSize

public void hasSize(int expectedSize)

Fails if the multimap does not have the given size.

containsKey

public void containsKey(@NullableDecl
                        Object key)

Fails if the multimap does not contain the given key.

doesNotContainKey

public void doesNotContainKey(@NullableDecl
                              Object key)

Fails if the multimap contains the given key.

containsEntry

public void containsEntry(@NullableDecl
                          Object key,
                          @NullableDecl
                          Object value)

Fails if the multimap does not contain the given entry.

doesNotContainEntry

public void doesNotContainEntry(@NullableDecl
                                Object key,
                                @NullableDecl
                                Object value)

Fails if the multimap contains the given entry.

valuesForKey

public IterableSubject valuesForKey(@NullableDecl
                                    Object key)

Returns a context-aware Subject for making assertions about the values for the given key within the Multimap.

This method performs no checks on its own and cannot cause test failures. Subsequent assertions must be chained onto this method call to test properties of the Multimap.

isEqualTo

public void isEqualTo(@NullableDecl
                      Object other)

Description copied from class: Subject

Fails if the subject is not equal to the given object. For the purposes of this comparison, two objects are equal if any of the following is true:

• they are equal according to Objects.equal(java.lang.Object, java.lang.Object)
• they are arrays and are considered equal by the appropriate Arrays.equals(long[], long[]) overload
• they are boxed integer types (Byte, Short, Character, Integer, or Long) and they are numerically equal when converted to Long.

Overrides:

isEqualTo in class Subject<MultimapSubject,Multimap<?,?>>

containsExactlyEntriesIn

@CanIgnoreReturnValue
public Ordered containsExactlyEntriesIn(Multimap<?,?> expectedMultimap)

Fails if the Multimap does not contain precisely the same entries as the argument Multimap.

A subsequent call to Ordered.inOrder() may be made if the caller wishes to verify that the two multimaps iterate fully in the same order. That is, their key sets iterate in the same order, and the value collections for each key iterate in the same order.

containsExactly

@CanIgnoreReturnValue
public Ordered containsExactly()

Fails if the multimap is not empty.

containsExactly

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

Fails if the multimap does not contain exactly the given set of key/value pairs.

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!

comparingValuesUsing

public <A,E> MultimapSubject.UsingCorrespondence<A,E> comparingValuesUsing(Correspondence<A,E> correspondence)

Starts a method chain for a check in which the actual values (i.e. the values of the Multimap under test) are compared to expected values using the given Correspondence. The actual values must be of type A, and the expected values must be of type E. The check is actually executed by continuing the method chain. For example:

 assertThat(actualMultimap)
   .comparingValuesUsing(correspondence)
   .containsEntry(expectedKey, expectedValue);
 

where actualMultimap is a Multimap<?, A> (or, more generally, a Multimap<?, ? extends A>), correspondence is a Correspondence<A, E>, and expectedValue is an E.

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

Any of the methods on the returned object may throw ClassCastException if they encounter an actual value that is not of type A.