ProtoSubject (Truth 0.45)

java.lang.Object
- com.google.common.truth.Subject<S,M>
- - com.google.common.truth.extensions.proto.LiteProtoSubject<S,M>
  - - com.google.common.truth.extensions.proto.ProtoSubject<S,M>

Type Parameters:

S - deprecated - the self-type, allowing this-returning methods to avoid needing subclassing. Both type parameters will be removed, as the methods that need them are being removed. You can prepare for this change by editing your class to refer to raw ProtoSubject today.

M - deprecated - the type of the message being tested by this Subject. Both type parameters will be removed, as the methods that need them are being removed. You can prepare for this change by editing your class to refer to raw ProtoSubject today.

All Implemented Interfaces:

ProtoFluentAssertion
```
public class ProtoSubject<S extends ProtoSubject<S,M>,M extends com.google.protobuf.Message>
extends LiteProtoSubject<S,M>
implements ProtoFluentAssertion
```
Truth subject for the full version of Protocol Buffers.
ProtoTruth.assertThat(actual).isEqualTo(expected) performs the same assertion as Truth.assertThat(actual).isEqualTo(expected), but with a better failure message. 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().isEqualTo(expected).
Floating-point fields are compared using exact equality, which is probably not what you want if the values are the results of some arithmetic. Support for approximate equality may be added in a later version.
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.

Nested Class Summary
- Nested classes/interfaces inherited from class com.google.common.truth.extensions.proto.LiteProtoSubject
  LiteProtoSubject.Factory<S extends LiteProtoSubject<S,M>,M extends com.google.protobuf.MessageLite>

Constructor Summary

Constructors
Modifier Constructor and Description

protected ProtoSubject(FailureMetadata failureMetadata, M message)

Constructors
Modifier	Constructor and Description
`protected`	`ProtoSubject(FailureMetadata failureMetadata, M message)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ProtoFluentAssertion`	`comparingExpectedFieldsOnly()` Limits the comparison of Protocol buffers to the fields set in the expected proto(s).
`void`	`hasAllRequiredFields()` Checks whether the subject has all required fields set.
`ProtoFluentAssertion`	`ignoringExtraRepeatedFieldElements()` 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.
`ProtoFluentAssertion`	`ignoringExtraRepeatedFieldElementsOfFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor first, com.google.protobuf.Descriptors.FieldDescriptor... rest)` Specifies that extra repeated field elements for these explicitly specified field descriptors should be ignored.
`ProtoFluentAssertion`	`ignoringExtraRepeatedFieldElementsOfFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)` Specifies that extra repeated field elements for these explicitly specified field descriptors should be ignored.
`ProtoFluentAssertion`	`ignoringExtraRepeatedFieldElementsOfFields(int firstFieldNumber, int... rest)` Specifies that extra repeated field elements for these explicitly specified top-level field numbers should be ignored.
`ProtoFluentAssertion`	`ignoringExtraRepeatedFieldElementsOfFields(Iterable<Integer> fieldNumbers)` Specifies that extra repeated field elements for these explicitly specified top-level field numbers should be ignored.
`ProtoFluentAssertion`	`ignoringFieldAbsence()` Specifies that the 'has' bit of individual fields should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringFieldAbsenceOfFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor, com.google.protobuf.Descriptors.FieldDescriptor... rest)` Specifies that the 'has' bit of these explicitly specified field descriptors should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringFieldAbsenceOfFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)` Specifies that the 'has' bit of these explicitly specified field descriptors should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringFieldAbsenceOfFields(int firstFieldNumber, int... rest)` Specifies that the 'has' bit of these explicitly specified top-level field numbers should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringFieldAbsenceOfFields(Iterable<Integer> fieldNumbers)` Specifies that the 'has' bit of these explicitly specified top-level field numbers should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor, com.google.protobuf.Descriptors.FieldDescriptor... rest)` Excludes all message fields matching the given `Descriptors.FieldDescriptor`s from the comparison.
`ProtoFluentAssertion`	`ignoringFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)` Excludes all message fields matching the given `Descriptors.FieldDescriptor`s from the comparison.
`ProtoFluentAssertion`	`ignoringFields(int firstFieldNumber, int... rest)` Excludes the top-level message fields with the given tag numbers from the comparison.
`ProtoFluentAssertion`	`ignoringFields(Iterable<Integer> fieldNumbers)` Excludes the top-level message fields with the given tag numbers from the comparison.
`ProtoFluentAssertion`	`ignoringFieldScope(FieldScope fieldScope)` Excludes all specific field paths under the argument `FieldScope` from the comparison.
`ProtoFluentAssertion`	`ignoringRepeatedFieldOrder()` Specifies that the ordering of repeated fields, at all levels, should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringRepeatedFieldOrderOfFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor, com.google.protobuf.Descriptors.FieldDescriptor... rest)` Specifies that the ordering of repeated fields for these explicitly specified field descriptors should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringRepeatedFieldOrderOfFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)` Specifies that the ordering of repeated fields for these explicitly specified field descriptors should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringRepeatedFieldOrderOfFields(int firstFieldNumber, int... rest)` Specifies that the ordering of repeated fields for these explicitly specified top-level field numbers should be ignored when comparing for equality.
`ProtoFluentAssertion`	`ignoringRepeatedFieldOrderOfFields(Iterable<Integer> fieldNumbers)` Specifies that the ordering of repeated fields for these explicitly specified top-level field numbers should be ignored when comparing for equality.
`void`	`isEqualTo(Object expected)` Checks whether the MessageLite is equivalent to the argument, using the standard equals() implementation.
`void`	`isNotEqualTo(Object expected)` Fails if the subject is equal to the given object.
`ProtoFluentAssertion`	`reportingMismatchesOnly()` 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.
`ProtoFluentAssertion`	`usingDoubleTolerance(double tolerance)` Compares double fields as equal if they are both finite and their absolute difference is less than or equal to `tolerance`.
`ProtoFluentAssertion`	`usingDoubleToleranceForFieldDescriptors(double tolerance, com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor, com.google.protobuf.Descriptors.FieldDescriptor... rest)` Compares double fields with these explicitly specified fields using the provided absolute tolerance.
`ProtoFluentAssertion`	`usingDoubleToleranceForFieldDescriptors(double tolerance, Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)` Compares double fields with these explicitly specified fields using the provided absolute tolerance.
`ProtoFluentAssertion`	`usingDoubleToleranceForFields(double tolerance, int firstFieldNumber, int... rest)` Compares double fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
`ProtoFluentAssertion`	`usingDoubleToleranceForFields(double tolerance, Iterable<Integer> fieldNumbers)` Compares double fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
`ProtoFluentAssertion`	`usingFloatTolerance(float tolerance)` Compares float fields as equal if they are both finite and their absolute difference is less than or equal to `tolerance`.
`ProtoFluentAssertion`	`usingFloatToleranceForFieldDescriptors(float tolerance, com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor, com.google.protobuf.Descriptors.FieldDescriptor... rest)` Compares float fields with these explicitly specified fields using the provided absolute tolerance.
`ProtoFluentAssertion`	`usingFloatToleranceForFieldDescriptors(float tolerance, Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)` Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
`ProtoFluentAssertion`	`usingFloatToleranceForFields(float tolerance, int firstFieldNumber, int... rest)` Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
`ProtoFluentAssertion`	`usingFloatToleranceForFields(float tolerance, Iterable<Integer> fieldNumbers)` Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
`ProtoFluentAssertion`	`withPartialScope(FieldScope fieldScope)` Limits the comparison of Protocol buffers to the defined `FieldScope`.

Methods inherited from class com.google.common.truth.extensions.proto.LiteProtoSubject
actualCustomStringRepresentation, isEqualTo, isEqualToDefaultInstance, isNotEqualTo, isNotEqualToDefaultInstance, serializedSize

Methods inherited from class com.google.common.truth.Subject
actual, actualAsString, check, equals, failWithActual, failWithActual, failWithoutActual, getSubject, hashCode, ignoreCheck, internalCustomName, isAnyOf, isIn, isInstanceOf, isNoneOf, isNotIn, isNotInstanceOf, isNotNull, isNotSameInstanceAs, isNull, isSameInstanceAs, named, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.google.common.truth.extensions.proto.ProtoFluentAssertion
equals, hashCode

- Constructor Detail
  - ProtoSubject
```
protected ProtoSubject(FailureMetadata failureMetadata,
                       @NullableDecl
                       M message)
```
- Method Detail
  - ignoringFieldAbsence
```
public ProtoFluentAssertion ignoringFieldAbsence()
```
    Description copied from interface: ProtoFluentAssertion
    
    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.
    
    Specified by:
    
    ignoringFieldAbsence in interface ProtoFluentAssertion
  - ignoringFieldAbsenceOfFields
```
public ProtoFluentAssertion ignoringFieldAbsenceOfFields(int firstFieldNumber,
                                                         int... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the 'has' bit of these explicitly specified top-level field numbers should be ignored when comparing for equality. Sub-fields must be specified explicitly (via Descriptors.FieldDescriptor) if they are to be ignored as well.
    Use ProtoFluentAssertion.ignoringFieldAbsence() instead to ignore the 'has' bit for all fields.
    
    Specified by:
    
    ignoringFieldAbsenceOfFields in interface ProtoFluentAssertion
    
    See Also:
    
    for details
  - ignoringFieldAbsenceOfFields
```
public ProtoFluentAssertion ignoringFieldAbsenceOfFields(Iterable<Integer> fieldNumbers)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the 'has' bit of these explicitly specified top-level field numbers should be ignored when comparing for equality. Sub-fields must be specified explicitly (via Descriptors.FieldDescriptor) if they are to be ignored as well.
    Use ProtoFluentAssertion.ignoringFieldAbsence() instead to ignore the 'has' bit for all fields.
    
    Specified by:
    
    ignoringFieldAbsenceOfFields in interface ProtoFluentAssertion
    
    See Also:
    
    for details
  - ignoringFieldAbsenceOfFieldDescriptors
```
public ProtoFluentAssertion ignoringFieldAbsenceOfFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor,
                                                                   com.google.protobuf.Descriptors.FieldDescriptor... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the 'has' bit of these explicitly specified field descriptors should be ignored when comparing for equality. Sub-fields must be specified explicitly if they are to be ignored as well.
    Use ProtoFluentAssertion.ignoringFieldAbsence() instead to ignore the 'has' bit for all fields.
    
    Specified by:
    
    ignoringFieldAbsenceOfFieldDescriptors in interface ProtoFluentAssertion
    
    See Also:
    
    for details
  - ignoringFieldAbsenceOfFieldDescriptors
```
public ProtoFluentAssertion ignoringFieldAbsenceOfFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the 'has' bit of these explicitly specified field descriptors should be ignored when comparing for equality. Sub-fields must be specified explicitly if they are to be ignored as well.
    Use ProtoFluentAssertion.ignoringFieldAbsence() instead to ignore the 'has' bit for all fields.
    
    Specified by:
    
    ignoringFieldAbsenceOfFieldDescriptors in interface ProtoFluentAssertion
    
    See Also:
    
    for details
  - ignoringRepeatedFieldOrder
```
public ProtoFluentAssertion ignoringRepeatedFieldOrder()
```
    Description copied from interface: ProtoFluentAssertion
    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 ProtoFluentAssertion.ignoringRepeatedFieldOrder(), 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.
    Specified by:
    
    ignoringRepeatedFieldOrder in interface ProtoFluentAssertion
  - ignoringRepeatedFieldOrderOfFields
```
public ProtoFluentAssertion ignoringRepeatedFieldOrderOfFields(int firstFieldNumber,
                                                               int... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the ordering of repeated fields for these explicitly specified top-level field numbers should be ignored when comparing for equality. Sub-fields must be specified explicitly (via Descriptors.FieldDescriptor) if their orders are to be ignored as well.
    Use ProtoFluentAssertion.ignoringRepeatedFieldOrder() instead to ignore order for all fields.
    
    Specified by:
    
    ignoringRepeatedFieldOrderOfFields in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - ignoringRepeatedFieldOrderOfFields
```
public ProtoFluentAssertion ignoringRepeatedFieldOrderOfFields(Iterable<Integer> fieldNumbers)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the ordering of repeated fields for these explicitly specified top-level field numbers should be ignored when comparing for equality. Sub-fields must be specified explicitly (via Descriptors.FieldDescriptor) if their orders are to be ignored as well.
    Use ProtoFluentAssertion.ignoringRepeatedFieldOrder() instead to ignore order for all fields.
    
    Specified by:
    
    ignoringRepeatedFieldOrderOfFields in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - ignoringRepeatedFieldOrderOfFieldDescriptors
```
public ProtoFluentAssertion ignoringRepeatedFieldOrderOfFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor,
                                                                         com.google.protobuf.Descriptors.FieldDescriptor... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the ordering of repeated fields for these explicitly specified field descriptors should be ignored when comparing for equality. Sub-fields must be specified explicitly if their orders are to be ignored as well.
    Use ProtoFluentAssertion.ignoringRepeatedFieldOrder() instead to ignore order for all fields.
    
    Specified by:
    
    ignoringRepeatedFieldOrderOfFieldDescriptors in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - ignoringRepeatedFieldOrderOfFieldDescriptors
```
public ProtoFluentAssertion ignoringRepeatedFieldOrderOfFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that the ordering of repeated fields for these explicitly specified field descriptors should be ignored when comparing for equality. Sub-fields must be specified explicitly if their orders are to be ignored as well.
    Use ProtoFluentAssertion.ignoringRepeatedFieldOrder() instead to ignore order for all fields.
    
    Specified by:
    
    ignoringRepeatedFieldOrderOfFieldDescriptors in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - ignoringExtraRepeatedFieldElements
```
public ProtoFluentAssertion ignoringExtraRepeatedFieldElements()
```
    Description copied from interface: ProtoFluentAssertion
    
    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 ProtoFluentAssertion.comparingExpectedFieldsOnly().
    This rule is applied independently from ProtoFluentAssertion.ignoringRepeatedFieldOrder(). 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.)
    
    Specified by:
    
    ignoringExtraRepeatedFieldElements in interface ProtoFluentAssertion
  - ignoringExtraRepeatedFieldElementsOfFields
```
public ProtoFluentAssertion ignoringExtraRepeatedFieldElementsOfFields(int firstFieldNumber,
                                                                       int... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that extra repeated field elements for these explicitly specified top-level field numbers should be ignored. Sub-fields must be specified explicitly (via Descriptors.FieldDescriptor) if their extra elements are to be ignored as well.
    Use ProtoFluentAssertion.ignoringExtraRepeatedFieldElements() instead to ignore these for all fields.
    
    Specified by:
    
    ignoringExtraRepeatedFieldElementsOfFields in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - ignoringExtraRepeatedFieldElementsOfFields
```
public ProtoFluentAssertion ignoringExtraRepeatedFieldElementsOfFields(Iterable<Integer> fieldNumbers)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that extra repeated field elements for these explicitly specified top-level field numbers should be ignored. Sub-fields must be specified explicitly (via Descriptors.FieldDescriptor) if their extra elements are to be ignored as well.
    Use ProtoFluentAssertion.ignoringExtraRepeatedFieldElements() instead to ignore these for all fields.
    
    Specified by:
    
    ignoringExtraRepeatedFieldElementsOfFields in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - ignoringExtraRepeatedFieldElementsOfFieldDescriptors
```
public ProtoFluentAssertion ignoringExtraRepeatedFieldElementsOfFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor first,
                                                                                 com.google.protobuf.Descriptors.FieldDescriptor... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that extra repeated field elements for these explicitly specified field descriptors should be ignored. Sub-fields must be specified explicitly if their extra elements are to be ignored as well.
    Use ProtoFluentAssertion.ignoringExtraRepeatedFieldElements() instead to ignore these for all fields.
    
    Specified by:
    
    ignoringExtraRepeatedFieldElementsOfFieldDescriptors in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - ignoringExtraRepeatedFieldElementsOfFieldDescriptors
```
public ProtoFluentAssertion ignoringExtraRepeatedFieldElementsOfFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)
```
    Description copied from interface: ProtoFluentAssertion
    
    Specifies that extra repeated field elements for these explicitly specified field descriptors should be ignored. Sub-fields must be specified explicitly if their extra elements are to be ignored as well.
    Use ProtoFluentAssertion.ignoringExtraRepeatedFieldElements() instead to ignore these for all fields.
    
    Specified by:
    
    ignoringExtraRepeatedFieldElementsOfFieldDescriptors in interface ProtoFluentAssertion
    
    See Also:
    
    for details.
  - usingDoubleTolerance
```
public ProtoFluentAssertion usingDoubleTolerance(double tolerance)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares double fields as equal if they are both finite and their absolute difference is less than or equal to tolerance.
    
    Specified by:
    
    usingDoubleTolerance in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingDoubleToleranceForFields
```
public ProtoFluentAssertion usingDoubleToleranceForFields(double tolerance,
                                                          int firstFieldNumber,
                                                          int... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares double fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
    
    Specified by:
    
    usingDoubleToleranceForFields in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingDoubleToleranceForFields
```
public ProtoFluentAssertion usingDoubleToleranceForFields(double tolerance,
                                                          Iterable<Integer> fieldNumbers)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares double fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
    
    Specified by:
    
    usingDoubleToleranceForFields in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingDoubleToleranceForFieldDescriptors
```
public ProtoFluentAssertion usingDoubleToleranceForFieldDescriptors(double tolerance,
                                                                    com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor,
                                                                    com.google.protobuf.Descriptors.FieldDescriptor... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares double fields with these explicitly specified fields using the provided absolute tolerance.
    
    Specified by:
    
    usingDoubleToleranceForFieldDescriptors in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingDoubleToleranceForFieldDescriptors
```
public ProtoFluentAssertion usingDoubleToleranceForFieldDescriptors(double tolerance,
                                                                    Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares double fields with these explicitly specified fields using the provided absolute tolerance.
    
    Specified by:
    
    usingDoubleToleranceForFieldDescriptors in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingFloatTolerance
```
public ProtoFluentAssertion usingFloatTolerance(float tolerance)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares float fields as equal if they are both finite and their absolute difference is less than or equal to tolerance.
    
    Specified by:
    
    usingFloatTolerance in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingFloatToleranceForFields
```
public ProtoFluentAssertion usingFloatToleranceForFields(float tolerance,
                                                         int firstFieldNumber,
                                                         int... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
    
    Specified by:
    
    usingFloatToleranceForFields in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingFloatToleranceForFields
```
public ProtoFluentAssertion usingFloatToleranceForFields(float tolerance,
                                                         Iterable<Integer> fieldNumbers)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
    
    Specified by:
    
    usingFloatToleranceForFields in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingFloatToleranceForFieldDescriptors
```
public ProtoFluentAssertion usingFloatToleranceForFieldDescriptors(float tolerance,
                                                                   com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor,
                                                                   com.google.protobuf.Descriptors.FieldDescriptor... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares float fields with these explicitly specified fields using the provided absolute tolerance.
    
    Specified by:
    
    usingFloatToleranceForFieldDescriptors in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - usingFloatToleranceForFieldDescriptors
```
public ProtoFluentAssertion usingFloatToleranceForFieldDescriptors(float tolerance,
                                                                   Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)
```
    Description copied from interface: ProtoFluentAssertion
    
    Compares float fields with these explicitly specified top-level field numbers using the provided absolute tolerance.
    
    Specified by:
    
    usingFloatToleranceForFieldDescriptors in interface ProtoFluentAssertion
    
    Parameters:
    
    tolerance - A finite, non-negative tolerance.
  - comparingExpectedFieldsOnly
```
public ProtoFluentAssertion comparingExpectedFieldsOnly()
```
    Description copied from interface: ProtoFluentAssertion
    
    Limits the comparison of Protocol buffers to the fields set in the expected proto(s). When multiple protos are specified, the comparison is limited to the union of set fields in all the expected protos.
    The "expected proto(s)" are those passed to the void method at the end of the ProtoFluentAssertion call-chain: For example, ProtoFluentAssertion.isEqualTo(Object), or ProtoFluentAssertion.isNotEqualTo(Object).
    Fields not set in the expected proto(s) are ignored. In particular, proto3 fields which have their default values are ignored, as these are indistinguishable from unset fields. If you want to assert that a proto3 message has certain fields with default values, you cannot use this method.
    
    Specified by:
    
    comparingExpectedFieldsOnly in interface ProtoFluentAssertion
  - withPartialScope
```
public ProtoFluentAssertion withPartialScope(FieldScope fieldScope)
```
    Description copied from interface: ProtoFluentAssertion
    
    Limits the comparison of Protocol buffers to the defined FieldScope.
    This method is additive and has well-defined ordering semantics. If the invoking ProtoFluentAssertion is already scoped to a FieldScope X, and this method is invoked with FieldScope Y, the resultant ProtoFluentAssertion is constrained to the intersection of FieldScopes X and Y.
    By default, ProtoFluentAssertion is constrained to FieldScopes.all(), that is, no fields are excluded from comparison.
    
    Specified by:
    
    withPartialScope in interface ProtoFluentAssertion
  - ignoringFields
```
public ProtoFluentAssertion ignoringFields(int firstFieldNumber,
                                           int... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    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.
    
    Specified by:
    
    ignoringFields in interface ProtoFluentAssertion
  - ignoringFields
```
public ProtoFluentAssertion ignoringFields(Iterable<Integer> fieldNumbers)
```
    Description copied from interface: ProtoFluentAssertion
    
    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.
    
    Specified by:
    
    ignoringFields in interface ProtoFluentAssertion
  - ignoringFieldDescriptors
```
public ProtoFluentAssertion ignoringFieldDescriptors(com.google.protobuf.Descriptors.FieldDescriptor firstFieldDescriptor,
                                                     com.google.protobuf.Descriptors.FieldDescriptor... rest)
```
    Description copied from interface: ProtoFluentAssertion
    
    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.
    
    Specified by:
    
    ignoringFieldDescriptors in interface ProtoFluentAssertion
  - ignoringFieldDescriptors
```
public ProtoFluentAssertion ignoringFieldDescriptors(Iterable<com.google.protobuf.Descriptors.FieldDescriptor> fieldDescriptors)
```
    Description copied from interface: ProtoFluentAssertion
    
    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.
    
    Specified by:
    
    ignoringFieldDescriptors in interface ProtoFluentAssertion
  - ignoringFieldScope
```
public ProtoFluentAssertion ignoringFieldScope(FieldScope fieldScope)
```
    Description copied from interface: ProtoFluentAssertion
    
    Excludes all specific field paths under the argument FieldScope from the comparison.
    This method is additive and has well-defined ordering semantics. If the invoking ProtoFluentAssertion is already scoped to a FieldScope X, and this method is invoked with FieldScope Y, the resultant ProtoFluentAssertion is constrained to the subtraction of X - Y.
    By default, ProtoFluentAssertion is constrained to FieldScopes.all(), that is, no fields are excluded from comparison.
    
    Specified by:
    
    ignoringFieldScope in interface ProtoFluentAssertion
  - reportingMismatchesOnly
```
public ProtoFluentAssertion reportingMismatchesOnly()
```
    Description copied from interface: ProtoFluentAssertion
    
    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.
    
    Specified by:
    
    reportingMismatchesOnly in interface ProtoFluentAssertion
  - isEqualTo
```
public void isEqualTo(@NullableDecl
                      Object expected)
```
    Description copied from class: LiteProtoSubject
    
    Checks whether the MessageLite is equivalent to the argument, using the standard equals() implementation.
    
    Specified by:
    
    isEqualTo in interface ProtoFluentAssertion
    
    Overrides:
    
    isEqualTo in class LiteProtoSubject<S extends ProtoSubject<S,M>,M extends com.google.protobuf.Message>
  - isNotEqualTo
```
public void isNotEqualTo(@NullableDecl
                         Object expected)
```
    Description copied from class: Subject
    
    Fails if the subject is equal to the given object. The meaning of equality is the same as for the Subject.isEqualTo(java.lang.Object) method.
    
    Specified by:
    
    isNotEqualTo in interface ProtoFluentAssertion
    
    Overrides:
    
    isNotEqualTo in class LiteProtoSubject<S extends ProtoSubject<S,M>,M extends com.google.protobuf.Message>
  - hasAllRequiredFields
```
public void hasAllRequiredFields()
```
    Description copied from class: LiteProtoSubject
    
    Checks whether the subject has all required fields set. Cannot fail for a proto built with build(), which itself fails if required fields aren't set.
    
    Overrides:
    
    hasAllRequiredFields in class LiteProtoSubject<S extends ProtoSubject<S,M>,M extends com.google.protobuf.Message>

Class ProtoSubject<S extends ProtoSubject<S,M>,M extends com.google.protobuf.Message>

Nested Class Summary

Nested classes/interfaces inherited from class com.google.common.truth.extensions.proto.LiteProtoSubject

Constructor Summary

Method Summary

Methods inherited from class com.google.common.truth.extensions.proto.LiteProtoSubject

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

Methods inherited from class java.lang.Object

Methods inherited from interface com.google.common.truth.extensions.proto.ProtoFluentAssertion

Constructor Detail

ProtoSubject

Method Detail

ignoringFieldAbsence

ignoringFieldAbsenceOfFields

ignoringFieldAbsenceOfFields

ignoringFieldAbsenceOfFieldDescriptors

ignoringFieldAbsenceOfFieldDescriptors

ignoringRepeatedFieldOrder

ignoringRepeatedFieldOrderOfFields

ignoringRepeatedFieldOrderOfFields

ignoringRepeatedFieldOrderOfFieldDescriptors

ignoringRepeatedFieldOrderOfFieldDescriptors

ignoringExtraRepeatedFieldElements

ignoringExtraRepeatedFieldElementsOfFields

ignoringExtraRepeatedFieldElementsOfFields

ignoringExtraRepeatedFieldElementsOfFieldDescriptors

ignoringExtraRepeatedFieldElementsOfFieldDescriptors

usingDoubleTolerance

usingDoubleToleranceForFields

usingDoubleToleranceForFields

usingDoubleToleranceForFieldDescriptors

usingDoubleToleranceForFieldDescriptors

usingFloatTolerance

usingFloatToleranceForFields

usingFloatToleranceForFields

usingFloatToleranceForFieldDescriptors

usingFloatToleranceForFieldDescriptors

comparingExpectedFieldsOnly

withPartialScope

ignoringFields

ignoringFields

ignoringFieldDescriptors

ignoringFieldDescriptors

ignoringFieldScope

reportingMismatchesOnly

isEqualTo

isNotEqualTo

hasAllRequiredFields