Package com.google.common.truth

Class MultimapSubject

  • public class MultimapSubject
extends Subject
    Propositions for Multimap subjects.

    • Field Detail

      • ALREADY_FAILED

        private static final Ordered ALREADY_FAILED
        Ordered implementation that does nothing because an earlier check already caused a failure.

      • actual

        private final com.google.common.collect.Multimap<?,​?> actual

    • Constructor Detail

      • MultimapSubject

        protected MultimapSubject​(FailureMetadata metadata,
                          com.google.common.collect.Multimap<?,​?> multimap)
        Constructor for use by subclasses. If you want to create an instance of this class itself, call check(...).that(actual).

      • MultimapSubject

        MultimapSubject​(FailureMetadata metadata,
                com.google.common.collect.Multimap<?,​?> multimap,
                java.lang.String typeDescription)

    • Method Detail

      • isEmpty

        public final void isEmpty()
        Fails if the multimap is not empty.

      • isNotEmpty

        public final void isNotEmpty()
        Fails if the multimap is empty.

      • hasSize

        public final void hasSize​(int expectedSize)
        Fails if the multimap does not have the given size.

      • containsKey

        public final void containsKey​(java.lang.Object key)
        Fails if the multimap does not contain the given key.

      • doesNotContainKey

        public final void doesNotContainKey​(java.lang.Object key)
        Fails if the multimap contains the given key.

      • containsEntry

        public final void containsEntry​(java.lang.Object key,
                                java.lang.Object value)
        Fails if the multimap does not contain the given entry.

      • doesNotContainEntry

        public final void doesNotContainEntry​(java.lang.Object key,
                                      java.lang.Object value)
        Fails if the multimap contains the given entry.

      • valuesForKey

        public IterableSubject valuesForKey​(java.lang.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 final void isEqualTo​(java.lang.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.
        • the actual value is a boxed floating-point type (Double or Float), the expected value is an Integer, and the two are numerically equal when converted to Double. (This allows assertThat(someDouble).isEqualTo(0) to pass.)

        Note: This method does not test the Object.equals(java.lang.Object) implementation itself; it assumes that method is functioning correctly according to its contract. Testing an equals implementation requires a utility such as guava-testlib's EqualsTester.

        In some cases, this method might not even call equals. It may instead perform other tests that will return the same result as long as equals is implemented according to the contract for its type.

        Overrides:
        isEqualTo in class Subject

      • containsExactlyEntriesIn

        public final Ordered containsExactlyEntriesIn​(com.google.common.collect.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.

      • containsAtLeastEntriesIn

        public final Ordered containsAtLeastEntriesIn​(com.google.common.collect.Multimap<?,​?> expectedMultimap)
        Fails if the Multimap does not contain at least the entries in the argument Multimap.

        A subsequent call to Ordered.inOrder() may be made if the caller wishes to verify that the entries are present in the same order as given. That is, the keys are present in the given order in the key set, and the values for each key are present in the given order order in the value collections.

      • containsExactly

        public final Ordered containsExactly()
        Fails if the multimap is not empty.

      • containsExactly

        public final Ordered containsExactly​(java.lang.Object k0,
                                     java.lang.Object v0,
                                     java.lang.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!

      • containsAtLeast

        public final Ordered containsAtLeast​(java.lang.Object k0,
                                     java.lang.Object v0,
                                     java.lang.Object... rest)
        Fails if the multimap does not contain at least the given 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!

      • accumulateMultimap

        private static com.google.common.collect.Multimap<java.lang.Object,​java.lang.Object> accumulateMultimap​(java.lang.Object k0,
                                                                                                              java.lang.Object v0,
                                                                                                              java.lang.Object... rest)

      • advanceToFind

        private static boolean advanceToFind​(java.util.Iterator<?> iterator,
                                     java.lang.Object value)
        Advances the iterator until it either returns value, or has no more elements.

        Returns true if the value was found, false if the end was reached before finding it.

        This is basically the same as Iterables.contains(java.lang.Iterable<? extends java.lang.Object>, java.lang.Object), but where the contract explicitly states that the iterator isn't advanced beyond the value if the value is found.

      • get

        private static <V> java.util.Collection<V> get​(com.google.common.collect.Multimap<?,​V> multimap,
                                               java.lang.Object key)

      • difference

        private static com.google.common.collect.ListMultimap<?,​?> difference​(com.google.common.collect.Multimap<?,​?> minuend,
                                                                            com.google.common.collect.Multimap<?,​?> subtrahend)

      • difference

        private static java.util.List<?> difference​(java.util.List<?> minuend,
                                            java.util.List<?> subtrahend)

      • countDuplicatesMultimap

        private static java.lang.String countDuplicatesMultimap​(com.google.common.collect.Multimap<?,​?> multimap)

      • annotateEmptyStringsMultimap

        private static com.google.common.collect.Multimap<?,​?> annotateEmptyStringsMultimap​(com.google.common.collect.Multimap<?,​?> multimap)
        Returns a multimap with all empty strings (as keys or values) replaced by a non-empty human understandable indicator for an empty string.

        Returns the given multimap if it contains no empty strings.

      • comparingValuesUsing

        public <A,​E> MultimapSubject.UsingCorrespondence<A,​E> comparingValuesUsing​(Correspondence<? super A,​? super 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.