code: public <A, E> IterableSubject.UsingCorrespondence<A, E> comparingElementsUsing(
        Correspondence<A, E> correspondence) {
      return delegate().comparingElementsUsing(correspondence);
    }
docs: Starts a method chain for a check in which the actual elements (i.e. the elements of the {@link
  Iterable} under test) are compared to expected elements using the given {@link Correspondence}.
  The actual elements must be of type {@code A}, the expected elements must be of type {@code E}.
  The check is actually executed by continuing the method chain. For example:
  
  <pre>{@code
  assertThat(actualIterable).comparingElementsUsing(correspondence).contains(expected);
  }</pre>
  
  where {@code actualIterable} is an {@code Iterable<A>} (or, more generally, an {@code
  Iterable<? extends A>}), {@code correspondence} is a {@code Correspondence<A, E>}, and {@code
  expected} is an {@code E}.
  
  <p>Any of the methods on the returned object may throw {@link ClassCastException} if they
  encounter an actual element that is not of type {@code A}.
  
  <p>Note that the {@code IterableOfProtosSubject} is designed to save you from having to write
  your own {@link Correspondence}. The configuration methods, such as {@link
  #ignoringRepeatedFieldOrder()} will construct a {@link Correspondence} under the hood which
  performs protobuf comparisons with {@link #ignoringRepeatedFieldOrder()}.