Package org.assertj.vavr.api

Class MultimapAssert<KEY,​VALUE>

  • Type Parameters:
    KEY - key type of the Multimap.
    VALUE - value type of the Multimap.
    All Implemented Interfaces:
    org.assertj.core.api.Assert<MultimapAssert<KEY,​VALUE>,​io.vavr.collection.Multimap<KEY,​VALUE>>, org.assertj.core.api.Descriptable<MultimapAssert<KEY,​VALUE>>, org.assertj.core.api.EnumerableAssert<MultimapAssert<KEY,​VALUE>,​io.vavr.Tuple2<? extends KEY,​? extends VALUE>>, org.assertj.core.api.ExtensionPoints<MultimapAssert<KEY,​VALUE>,​io.vavr.collection.Multimap<KEY,​VALUE>>
    public class MultimapAssert<KEY,​VALUE>
extends org.assertj.core.api.AbstractObjectAssert<SELF,​ACTUAL>
    Assertions for Multimap.
    Author:
    Michał Chmielarz

    • Field Summary

      • Fields inherited from class org.assertj.core.api.AbstractAssert

        actual, info, myself, throwUnsupportedExceptionOnEquals

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      ACTUAL actual()  
      SELF allSatisfy​(BiConsumer<? super KEY,​? super VALUE> entryRequirements)
      Verifies that all the actual multimap entries satisfy the given entryRequirements.
      SELF contains​(io.vavr.Tuple2<KEY,​VALUE>... entries)
      Verifies that the actual multimap contains the given entries, in any order.
      SELF containsAllEntriesOf​(Iterable<io.vavr.Tuple2<KEY,​VALUE>> other)
      Verifies that the actual multimap contains all entries of the given iterable, in any order.
      SELF containsAnyOf​(io.vavr.Tuple2<KEY,​VALUE>... entries)
      Verifies that the actual multimap contains at least one of the given entries.
      SELF containsEntry​(KEY key, VALUE value)
      Verifies that the actual multimap contains the given entry.
      SELF containsExactly​(io.vavr.Tuple2<? extends KEY,​? extends VALUE>... entries)
      Verifies that the actual multimap 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 containsKey​(KEY key)
      Verifies that the actual multimap contains the given key.
      SELF containsKeys​(KEY... keys)
      Verifies that the actual multimap contains the given keys.
      SELF containsOnly​(Iterable<io.vavr.Tuple2<KEY,​VALUE>> entries)  
      SELF containsOnlyKeys​(KEY... keys)
      Verifies that the actual multimap contains only the given keys and nothing else, in any order.
      SELF containsValue​(VALUE value)
      Verifies that the actual multimap contains the given value.
      SELF containsValues​(VALUE... values)
      Verifies that the actual multimap contains the given values.
      SELF doesNotContain​(io.vavr.Tuple2<KEY,​VALUE>... entries)
      Verifies that the actual multimap does not contain the given entries.
      SELF doesNotContainEntry​(KEY key, VALUE value)
      Verifies that the actual multimap does not contain the given entry.
      SELF doesNotContainKey​(KEY key)
      Verifies that the actual multimap does not contain the given key.
      SELF doesNotContainKeys​(KEY... keys)
      Verifies that the actual multimap does not contain the given keys.
      SELF doesNotContainValue​(VALUE value)
      Verifies that the actual multimap does not contain the given value.
      SELF doesNotContainValues​(VALUE... values)
      Verifies that the actual multimap does not contain the given values.
      SELF hasEntrySatisfying​(KEY key, org.assertj.core.api.Condition<? super VALUE> valueCondition)
      Verifies that the actual multimap contains a value for the given key that satisfies the given valueCondition.
      SELF hasSameSizeAs​(Iterable<?> other)  
      SELF hasSameSizeAs​(Object array)  
      SELF hasSize​(int expectedSize)  
      SELF hasSizeBetween​(int lowerBoundary, int higherBoundary)  
      SELF hasSizeGreaterThan​(int boundary)  
      SELF hasSizeGreaterThanOrEqualTo​(int boundary)  
      SELF hasSizeLessThan​(int boundary)  
      SELF hasSizeLessThanOrEqualTo​(int boundary)  
      org.assertj.core.api.WritableAssertionInfo info()  
      void isEmpty()  
      SELF isNotEmpty()  
      void isNullOrEmpty()  
      org.assertj.core.internal.Objects objects()  
      SELF usingDefaultElementComparator()  
      SELF usingElementComparator​(Comparator<? super io.vavr.Tuple2<? extends KEY,​? extends VALUE>> customComparator)  
      SELF withAssertionState​(org.assertj.vavr.api.AbstractVavrAssert assertInstance)  

      • Methods inherited from class org.assertj.core.api.AbstractObjectAssert

        as, as, extracting, extracting, extracting, extracting, extracting, extracting, getComparatorsByType, hasAllNullFieldsOrProperties, hasAllNullFieldsOrPropertiesExcept, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, hasOnlyFields, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, newObjectAssert, returns, usingComparatorForFields, usingComparatorForType, usingRecursiveComparison, usingRecursiveComparison

      • Methods inherited from class org.assertj.core.api.AbstractAssert

        asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError

      • Methods inherited from interface org.assertj.core.api.Descriptable

        as, describedAs

    • Method Detail

      • contains

        public SELF contains​(io.vavr.Tuple2<KEY,​VALUE>... entries)
        Verifies that the actual multimap contains the given entries, in any order.

        This assertion succeeds if both actual multimap and given entries are empty.

        Parameters:
        entries - the given entries.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given argument is null.
        NullPointerException - if any of the entries in the given array is null.
        AssertionError - if the actual multimap is not empty and the given argument is an empty array.
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given entries.

      • containsAnyOf

        public SELF containsAnyOf​(io.vavr.Tuple2<KEY,​VALUE>... entries)
        Verifies that the actual multimap contains at least one of the given entries.
        Parameters:
        entries - the given entries.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given argument is null.
        NullPointerException - if any of the entries in the given array is null.
        AssertionError - if the actual multimap is not empty and the given argument is an empty array.
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain any of the given entries.

      • containsAllEntriesOf

        public SELF containsAllEntriesOf​(Iterable<io.vavr.Tuple2<KEY,​VALUE>> other)
        Verifies that the actual multimap contains all entries of the given iterable, in any order.
        Parameters:
        other - the iterable with the given entries.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given argument is null.
        NullPointerException - if any of the entries in the given iterable is null.
        AssertionError - if the actual multimap is not empty and the given argument is an empty iterable.
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given entries.

      • containsOnly

        public SELF containsOnly​(Iterable<io.vavr.Tuple2<KEY,​VALUE>> entries)

      • containsExactly

        public SELF containsExactly​(io.vavr.Tuple2<? extends KEY,​? extends VALUE>... entries)
        Verifies that the actual multimap 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. don't use it with HashMultimap, prefer containsOnly(java.lang.Iterable<io.vavr.Tuple2<KEY, VALUE>>) methods in that case).
        Parameters:
        entries - the given entries.
        Returns:
        this assertions object.
        Throws:
        NullPointerException - if the given entries array is null.
        AssertionError - if the actual multimap is null.
        IllegalArgumentException - if the given entries array is empty.
        AssertionError - if the actual multimap does not contain the given entries with same order, i.e. the actual multimap contains some or none of the given entries, or the actual multimap contains more entries than the given ones or entries are the same but the order is not.

      • allSatisfy

        public SELF allSatisfy​(BiConsumer<? super KEY,​? super VALUE> entryRequirements)
        Verifies that all the actual multimap entries satisfy the given entryRequirements. If the actual multimap is empty, this assertion succeeds as there is nothing to check.
        Parameters:
        entryRequirements - the given requirements that each entry must satisfy.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given entryRequirements BiConsumer is null.
        AssertionError - if the actual multimap is null.
        AssertionError - if one or more entries don't satisfy the given requirements.

      • hasEntrySatisfying

        public SELF hasEntrySatisfying​(KEY key,
                               org.assertj.core.api.Condition<? super VALUE> valueCondition)
        Verifies that the actual multimap contains a value for the given key that satisfies the given valueCondition.
        Parameters:
        key - the given key to check.
        valueCondition - the given condition for check value.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given values is null.
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given key.
        AssertionError - if the actual multimap contains the given key, but value does not match the given valueCondition.

      • containsEntry

        public SELF containsEntry​(KEY key,
                          VALUE value)
        Verifies that the actual multimap contains the given entry.
        Parameters:
        key - the given key to check.
        value - the given value to check.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given entries.

      • doesNotContain

        public SELF doesNotContain​(io.vavr.Tuple2<KEY,​VALUE>... entries)
        Verifies that the actual multimap does not contain the given entries.
        Parameters:
        entries - the given entries.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given argument is null.
        IllegalArgumentException - if the given argument is an empty array.
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap contains any of the given entries.

      • doesNotContainEntry

        public SELF doesNotContainEntry​(KEY key,
                                VALUE value)
        Verifies that the actual multimap does not contain the given entry.
        Parameters:
        key - key of the entry.
        value - value of the entry.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given argument is null.
        IllegalArgumentException - if the given argument is an empty array.
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap contains any of the given entries.

      • containsKey

        public SELF containsKey​(KEY key)
        Verifies that the actual multimap contains the given key.
        Parameters:
        key - the given key.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given key.

      • containsKeys

        public SELF containsKeys​(KEY... keys)
        Verifies that the actual multimap contains the given keys.
        Parameters:
        keys - the given keys.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given key.
        IllegalArgumentException - if the given argument is an empty array.
        NullPointerException - if the array of keys is null.

      • containsOnlyKeys

        public SELF containsOnlyKeys​(KEY... keys)
        Verifies that the actual multimap contains only the given keys and nothing else, in any order.
        Parameters:
        keys - the given keys that should be in the actual multimap.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given keys, i.e. the actual multimap contains some or none of the given keys, or the actual multimap contains more entries than the given ones.
        NullPointerException - if the array of keys is null.
        IllegalArgumentException - if the given argument is an empty array.

      • doesNotContainKey

        public SELF doesNotContainKey​(KEY key)
        Verifies that the actual multimap does not contain the given key.
        Parameters:
        key - the given key.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap contains the given key.

      • doesNotContainKeys

        public SELF doesNotContainKeys​(KEY... keys)
        Verifies that the actual multimap does not contain the given keys.
        Parameters:
        keys - the given keys.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap contains the given key.
        IllegalArgumentException - if the given argument is an empty array.
        NullPointerException - if the array of keys is null.

      • containsValue

        public SELF containsValue​(VALUE value)
        Verifies that the actual multimap contains the given value.
        Parameters:
        value - the value to look for.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given value.

      • containsValues

        public SELF containsValues​(VALUE... values)
        Verifies that the actual multimap contains the given values.
        Parameters:
        values - the values to look for in the actual map.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap does not contain the given values.

      • doesNotContainValue

        public SELF doesNotContainValue​(VALUE value)
        Verifies that the actual multimap does not contain the given value.
        Parameters:
        value - the value to look for.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap contains the given value.

      • doesNotContainValues

        public SELF doesNotContainValues​(VALUE... values)
        Verifies that the actual multimap does not contain the given values.
        Parameters:
        values - the values to look for in the actual map.
        Returns:
        this assertions object.
        Throws:
        AssertionError - if the actual multimap is null.
        AssertionError - if the actual multimap contains the given values.

      • isNullOrEmpty

        public void isNullOrEmpty()
        Specified by:
        isNullOrEmpty in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • isEmpty

        public void isEmpty()
        Specified by:
        isEmpty in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • isNotEmpty

        public SELF isNotEmpty()
        Specified by:
        isNotEmpty in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSize

        public SELF hasSize​(int expectedSize)
        Specified by:
        hasSize in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSizeGreaterThan

        public SELF hasSizeGreaterThan​(int boundary)
        Specified by:
        hasSizeGreaterThan in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSizeGreaterThanOrEqualTo

        public SELF hasSizeGreaterThanOrEqualTo​(int boundary)
        Specified by:
        hasSizeGreaterThanOrEqualTo in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSizeLessThan

        public SELF hasSizeLessThan​(int boundary)
        Specified by:
        hasSizeLessThan in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSizeLessThanOrEqualTo

        public SELF hasSizeLessThanOrEqualTo​(int boundary)
        Specified by:
        hasSizeLessThanOrEqualTo in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSizeBetween

        public SELF hasSizeBetween​(int lowerBoundary,
                           int higherBoundary)
        Specified by:
        hasSizeBetween in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSameSizeAs

        public SELF hasSameSizeAs​(Iterable<?> other)
        Specified by:
        hasSameSizeAs in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • hasSameSizeAs

        public SELF hasSameSizeAs​(Object array)
        Specified by:
        hasSameSizeAs in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • usingElementComparator

        public SELF usingElementComparator​(Comparator<? super io.vavr.Tuple2<? extends KEY,​? extends VALUE>> customComparator)
        Specified by:
        usingElementComparator in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • usingDefaultElementComparator

        public SELF usingDefaultElementComparator()
        Specified by:
        usingDefaultElementComparator in interface org.assertj.core.api.EnumerableAssert<SELF extends org.assertj.vavr.api.AbstractMultimapAssert<SELF,​ACTUAL,​KEY,​VALUE>,​ACTUAL extends io.vavr.collection.Multimap<KEY,​VALUE>>

      • actual

        public ACTUAL actual()

      • withAssertionState

        public SELF withAssertionState​(org.assertj.vavr.api.AbstractVavrAssert assertInstance)

      • objects

        public org.assertj.core.internal.Objects objects()

      • info

        public org.assertj.core.api.WritableAssertionInfo info()