@Override
  protected abstract Multimap<K, V> delegate();

  @Override
  public Map<K, Collection<V>> asMap() {
    return delegate().asMap();
  }

  @Override
  public void clear() {
    delegate().clear();
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    return delegate().containsEntry(key, value);
  }

  @Override

 * this permits any interval to be used.
 */
internal class ThrottledSink(
  private val socket: MockWebServerSocket,
  private val delegate: Sink,
  private val bytesPerPeriod: Long,
  private val periodDelayNanos: Long,
) : Sink by delegate {
  private var bytesWrittenSinceLastDelay = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    var bytesLeft = byteCount

    private final Deque<E> delegate = new LinkedList<>();
    private final Object mutex = new Object[0]; // something Serializable

    @Override
    public boolean offer(E o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.offer(o);
    }

    @Override
    public @Nullable E poll() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.poll();
    }

    @Override

    private final ExecutionListener delegate;

    EventSpyExecutionListener(EventSpyDispatcher dispatcher, ExecutionListener delegate) {
        this.dispatcher = dispatcher;
        this.delegate = delegate;
    }

    @Override
    public void projectDiscoveryStarted(ExecutionEvent event) {
        dispatcher.onEvent(event);
        delegate.projectDiscoveryStarted(event);
    }

    @Override

    private final TestSortedSetGenerator<E> delegate;

    public SortedSetSubsetTestSetGenerator(
        TestSortedSetGenerator<E> delegate, Bound to, Bound from) {
      this.to = to;
      this.from = from;
      this.delegate = delegate;

      SortedSet<E> emptySet = delegate.create();
      this.comparator = emptySet.comparator();

      SampleElements<E> samples = delegate.samples();

    assertThat(future.setFuture(delegate)).isTrue();
    assertThat(future.cancel(true /* mayInterruptIfRunning */)).isTrue();
    assertCancelled(future, true);
    assertCancelled(delegate, true);
  }

  public void testSetFutureDelegateAlreadySuccessful() throws Exception {
    delegate.set(5);
    assertThat(future.setFuture(delegate)).isTrue();
    assertSuccessful(future, 5);
  }

          @Override
          public NoDelegateToEquals apply(Equals delegate) {
            return new NoDelegateToEquals(delegate);
          }
        };

    private final Equals delegate;

    NoDelegateToEquals(Equals delegate) {
      this.delegate = delegate;
    }

    @Override
    public String toString() {
      return delegate.toString();
    }
  }

  private final ListenableFuture<V> delegate;

  ForwardingFluentFuture(ListenableFuture<V> delegate) {
    this.delegate = checkNotNull(delegate);
  }

  @Override
  public void addListener(Runnable listener, Executor executor) {
    delegate.addListener(listener, executor);
  }

  @Override
  public boolean cancel(boolean mayInterruptIfRunning) {
    return delegate.cancel(mayInterruptIfRunning);
  }

public class SwitchableMetadataSource implements ArtifactMetadataSource {
    private ArtifactMetadataSource delegate;

    @Inject
    public SwitchableMetadataSource(@Named("test") ArtifactMetadataSource delegate) {
        this.delegate = delegate;
    }

    public void setDelegate(ArtifactMetadataSource delegate) {
        this.delegate = delegate;
    }

    @Override

      implements Serializable {
    final Object delegate;

    DelegatingInvocationHandler(Object delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    protected Object handleInvocation(Object proxy, Method method, Object[] args) throws Throwable {
      return method.invoke(delegate, args);
    }

    @Override
    public String toString() {