Package com.google.common.truth.extensions.proto

Class MultimapWithProtoValuesSubject<M extends Message>

  • Type Parameters:
    M - the type of the message values in the multimap
    public class MultimapWithProtoValuesSubject<M extends Message>
extends MultimapSubject
    Truth subject for Multimaps with protocol buffers for values.

    ProtoTruth.assertThat(actual).containsExactlyEntriesIn(expected) performs the same assertion as Truth.assertThat(actual).containsExactlyEntriesIn(expected). By default, the assertions are strict with respect to repeated field order, missing fields, etc. This behavior can be changed with the configuration methods on this subject, e.g. ProtoTruth.assertThat(actual).ignoringRepeatedFieldOrder().containsExactlyEntriesIn(expected).

    By default, floating-point fields are compared using exact equality, which is probably not what you want if the values are the results of some arithmetic. To check for approximate equality, use usingDoubleToleranceForValues(double), usingFloatToleranceForValues(float), and their per-field equivalents.

    Equality tests, and other methods, may yield slightly different behavior for versions 2 and 3 of Protocol Buffers. If testing protos of multiple versions, make sure you understand the behaviors of default and unknown fields so you don't under or over test.

    • Constructor Detail

      • MultimapWithProtoValuesSubject

        protected MultimapWithProtoValuesSubject​(FailureMetadata failureMetadata,
                                         @Nullable Multimap<?,​M> multimap)

    • Method Detail

      • valuesForKey

        public IterableOfProtosSubject<M> valuesForKey​(@Nullable 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.

        Overrides:
        valuesForKey in class MultimapSubject

      • ignoringFieldAbsenceForValues

        public MultimapWithProtoValuesFluentAssertion<M> ignoringFieldAbsenceForValues()
        Specifies that the 'has' bit of individual fields should be ignored when comparing for equality.

        For version 2 Protocol Buffers, this setting determines whether two protos with the same value for a field compare equal if one explicitly sets the value, and the other merely implicitly uses the schema-defined default. This setting also determines whether unknown fields should be considered in the comparison. By ignoringFieldAbsence(), unknown fields are ignored, and value-equal fields as specified above are considered equal.

        For version 3 Protocol Buffers, this setting does not affect primitive fields, because their default value is indistinguishable from unset.

      • ignoringRepeatedFieldOrderForValues

        public MultimapWithProtoValuesFluentAssertion<M> ignoringRepeatedFieldOrderForValues()
        Specifies that the ordering of repeated fields, at all levels, should be ignored when comparing for equality.

        This setting applies to all repeated fields recursively, but it does not ignore structure. For example, with ignoringRepeatedFieldOrderForValues(), a repeated int32 field bar, set inside a repeated message field foo, the following protos will all compare equal: 

        
 message1: {
   foo: {
     bar: 1
     bar: 2
   }
   foo: {
     bar: 3
     bar: 4
   }
 }

 message2: {
   foo: {
     bar: 2
     bar: 1
   }
   foo: {
     bar: 4
     bar: 3
   }
 }

 message3: {
   foo: {
     bar: 4
     bar: 3
   }
   foo: {
     bar: 2
     bar: 1
   }
 }

        However, the following message will compare equal to none of these: 

        
 message4: {
   foo: {
     bar: 1
     bar: 3
   }
   foo: {
     bar: 2
     bar: 4
   }
 }

        This setting does not apply to map fields, for which field order is always ignored. The serialization order of map fields is undefined, and it may change from runtime to runtime.

      • ignoringExtraRepeatedFieldElementsForValues

        public MultimapWithProtoValuesFluentAssertion<M> ignoringExtraRepeatedFieldElementsForValues()
        Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are not found in the 'expected' proto are ignored, with the exception of fields in the expected proto which are empty. To ignore empty repeated fields as well, use comparingExpectedFieldsOnlyForValues().

        This rule is applied independently from ignoringRepeatedFieldOrderForValues(). If ignoring repeated field order AND extra repeated field elements, all that is tested is that the expected elements comprise a subset of the actual elements. If not ignoring repeated field order, but still ignoring extra repeated field elements, the actual elements must contain a subsequence that matches the expected elements for the test to pass. (The subsequence rule does not apply to Map fields, which are always compared by key.)

      • usingDoubleToleranceForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingDoubleToleranceForValues​(double tolerance)
        Compares double fields as equal if they are both finite and their absolute difference is less than or equal to tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • usingDoubleToleranceForFieldsForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingDoubleToleranceForFieldsForValues​(double tolerance,
                                                                                        int firstFieldNumber,
                                                                                        int... rest)
        Compares double fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • usingDoubleToleranceForFieldsForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingDoubleToleranceForFieldsForValues​(double tolerance,
                                                                                        Iterable<Integer> fieldNumbers)
        Compares double fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • usingDoubleToleranceForFieldDescriptorsForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingDoubleToleranceForFieldDescriptorsForValues​(double tolerance,
                                                                                                  Iterable<Descriptors.FieldDescriptor> fieldDescriptors)
        Compares double fields with these explicitly specified fields using the provided absolute tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • usingFloatToleranceForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingFloatToleranceForValues​(float tolerance)
        Compares float fields as equal if they are both finite and their absolute difference is less than or equal to tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • usingFloatToleranceForFieldsForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingFloatToleranceForFieldsForValues​(float tolerance,
                                                                                       int firstFieldNumber,
                                                                                       int... rest)
        Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • usingFloatToleranceForFieldsForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingFloatToleranceForFieldsForValues​(float tolerance,
                                                                                       Iterable<Integer> fieldNumbers)
        Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • usingFloatToleranceForFieldDescriptorsForValues

        public MultimapWithProtoValuesFluentAssertion<M> usingFloatToleranceForFieldDescriptorsForValues​(float tolerance,
                                                                                                 Iterable<Descriptors.FieldDescriptor> fieldDescriptors)
        Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
        Parameters:
        tolerance - A finite, non-negative tolerance.

      • ignoringFieldsForValues

        public MultimapWithProtoValuesFluentAssertion<M> ignoringFieldsForValues​(int firstFieldNumber,
                                                                         int... rest)
        Excludes the top-level message fields with the given tag numbers from the comparison.

        This method adds on any previous FieldScope related settings, overriding previous changes to ensure the specified fields are ignored recursively. All sub-fields of these field numbers are ignored, and all sub-messages of type M will also have these field numbers ignored.

        If an invalid field number is supplied, the terminal comparison operation will throw a runtime exception.

      • ignoringFieldsForValues

        public MultimapWithProtoValuesFluentAssertion<M> ignoringFieldsForValues​(Iterable<Integer> fieldNumbers)
        Excludes the top-level message fields with the given tag numbers from the comparison.

        This method adds on any previous FieldScope related settings, overriding previous changes to ensure the specified fields are ignored recursively. All sub-fields of these field numbers are ignored, and all sub-messages of type M will also have these field numbers ignored.

        If an invalid field number is supplied, the terminal comparison operation will throw a runtime exception.

      • ignoringFieldDescriptorsForValues

        public MultimapWithProtoValuesFluentAssertion<M> ignoringFieldDescriptorsForValues​(Descriptors.FieldDescriptor firstFieldDescriptor,
                                                                                   Descriptors.FieldDescriptor... rest)
        Excludes all message fields matching the given Descriptors.FieldDescriptors from the comparison.

        This method adds on any previous FieldScope related settings, overriding previous changes to ensure the specified fields are ignored recursively. All sub-fields of these field descriptors are ignored, no matter where they occur in the tree.

        If a field descriptor which does not, or cannot occur in the proto structure is supplied, it is silently ignored.

      • ignoringFieldDescriptorsForValues

        public MultimapWithProtoValuesFluentAssertion<M> ignoringFieldDescriptorsForValues​(Iterable<Descriptors.FieldDescriptor> fieldDescriptors)
        Excludes all message fields matching the given Descriptors.FieldDescriptors from the comparison.

        This method adds on any previous FieldScope related settings, overriding previous changes to ensure the specified fields are ignored recursively. All sub-fields of these field descriptors are ignored, no matter where they occur in the tree.

        If a field descriptor which does not, or cannot occur in the proto structure is supplied, it is silently ignored.

      • reportingMismatchesOnlyForValues

        public MultimapWithProtoValuesFluentAssertion<M> reportingMismatchesOnlyForValues()
        If set, in the event of a comparison failure, the error message printed will list only those specific fields that did not match between the actual and expected values. Useful for very large protocol buffers.

        This a purely cosmetic setting, and it has no effect on the behavior of the test.

      • unpackingAnyUsingForValues

        public MultimapWithProtoValuesFluentAssertion<M> unpackingAnyUsingForValues​(TypeRegistry typeRegistry,
                                                                            ExtensionRegistry extensionRegistry)
        Specifies the TypeRegistry and ExtensionRegistry to use for Any messages.

        To compare the value of an Any message, ProtoTruth looks in the given type registry for a descriptor for the message's type URL:

        • If ProtoTruth finds a descriptor, it unpacks the value and compares it against the expected value, respecting any configuration methods used for the assertion.
        • If ProtoTruth does not find a descriptor (or if the value can't be deserialized with the descriptor), it compares the raw, serialized bytes of the expected and actual values.

        When ProtoTruth unpacks a value, it is parsing a serialized proto. That proto may contain extensions. To look up those extensions, ProtoTruth uses the provided ExtensionRegistry.

        Since:
        1.1