.addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> Multiset<T> wrap(final Multiset<T> delegate) {
    return new ForwardingMultiset<T>() {
      @Override
      protected Multiset<T> delegate() {
        return delegate;
      }
    };
  }

      return new ImmutableTypeToInstanceMap<>(mapBuilder.buildOrThrow());
    }
  }

  private final ImmutableMap<TypeToken<? extends B>, B> delegate;

  private ImmutableTypeToInstanceMap(ImmutableMap<TypeToken<? extends B>, B> delegate) {
    this.delegate = delegate;
  }

  @Override
  @CheckForNull
  public <T extends B> T getInstance(TypeToken<T> type) {
    return trustedGet(type.rejectTypeVariables());

        .addEqualityGroup(list2, wrap(list2))
        .testEquals();
  }

  private static <T> List<T> wrap(final List<T> delegate) {
    return new ForwardingList<T>() {
      @Override
      protected List<T> delegate() {
        return delegate;
      }
    };
  }

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> SortedMultiset<T> wrap(final SortedMultiset<T> delegate) {
    return new ForwardingSortedMultiset<T>() {
      @Override
      protected SortedMultiset<T> delegate() {
        return delegate;
      }
    };
  }

    return delegate().remove(element, occurrences);
  }

  @Override
  public Set<E> elementSet() {
    return delegate().elementSet();
  }

  @Override
  public Set<Entry<E>> entrySet() {
    return delegate().entrySet();
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    return object == this || delegate().equals(object);
  }

  @Override

        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

  private static <T> NavigableSet<T> wrap(final NavigableSet<T> delegate) {
    return new ForwardingNavigableSet<T>() {
      @Override
      protected NavigableSet<T> delegate() {
        return delegate;
      }
    };
  }

    return ImmutableMultimap.<String, Integer>of().asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> delegate = HashMultimap.create();
    populate(delegate);
    return ImmutableMultimap.copyOf(delegate).asMap();
  }

  }

  class BiMapEntry extends ForwardingMapEntry<K, V> {
    private final Entry<K, V> delegate;

    BiMapEntry(Entry<K, V> delegate) {
      this.delegate = delegate;
    }

    @Override
    protected Entry<K, V> delegate() {
      return delegate;
    }

    @Override
    public V setValue(V value) {
      checkValue(value);

@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
abstract class WrappingExecutorService implements ExecutorService {
  private final ExecutorService delegate;

  protected WrappingExecutorService(ExecutorService delegate) {
    this.delegate = checkNotNull(delegate);
  }

  /**
   * Wraps a {@code Callable} for submission to the underlying executor. This method is also applied

  static class SynchronizedObject implements Serializable {
    final Object delegate;
    final Object mutex;

    SynchronizedObject(Object delegate, @CheckForNull Object mutex) {
      this.delegate = checkNotNull(delegate);
      this.mutex = (mutex == null) ? this : mutex;
    }

    Object delegate() {
      return delegate;
    }

    // No equals and hashCode; see ForwardingObject for details.