* this permits any interval to be used.
 */
internal class ThrottledSink(
  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

import okio.BufferedSource

open class ForwardingResponseBody(delegate: ResponseBody?) : ResponseBody() {
  private val delegate: ResponseBody

  fun delegate(): ResponseBody {
    return delegate
  }

  override fun contentType(): MediaType? {
    return delegate.contentType()
  }

  override fun contentLength(): Long {
    return delegate.contentLength()
  }

  override fun source(): BufferedSource {

    protected Object delegate;

    public BaseObject() {}

    public BaseObject(Object delegate, BaseObject parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent != null ? parent::replace : null;
    }

    public BaseObject(Object delegate, ChildrenTracking parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");

    private final Callable<T> delegate;

    public WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    public WrappedRunnable(Runnable delegate) {

    private final org.apache.maven.plugin.MojoExecution delegate;

    public DefaultMojoExecution(InternalMavenSession session, org.apache.maven.plugin.MojoExecution delegate) {
        this.session = session;
        this.delegate = delegate;
    }

    public org.apache.maven.plugin.MojoExecution getDelegate() {
        return delegate;
    }

    @Override
    public Plugin getPlugin() {

  final transient Collection<E> delegate;

  ForwardingImmutableCollection(Collection<E> delegate) {
    this.delegate = delegate;
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return Iterators.unmodifiableIterator(delegate.iterator());
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && delegate.contains(object);
  }

  @Override

    assertThat(body.bytes()).isEqualTo(text)
  }
}

abstract class ForwardingSource(
  val delegate: Source,
) : Source {
  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long = delegate.read(sink, byteCount)

  override fun timeout() = delegate.timeout()

  override fun close() = delegate.close()

  @Override
  protected abstract BlockingDeque<E> delegate();

  @Override
  public int remainingCapacity() {
    return delegate().remainingCapacity();
  }

  @Override
  public void putFirst(E e) throws InterruptedException {
    delegate().putFirst(e);
  }

  @Override
  public void putLast(E e) throws InterruptedException {
    delegate().putLast(e);
  }

  @Override

   *
   * @since 10.0
   */
  public abstract static class SimpleForwardingLoadingCache<K, V>
      extends ForwardingLoadingCache<K, V> {
    private final LoadingCache<K, V> delegate;

    protected SimpleForwardingLoadingCache(LoadingCache<K, V> delegate) {
      this.delegate = Preconditions.checkNotNull(delegate);
    }

    @Override
    protected final LoadingCache<K, V> delegate() {

/**
 * An SSLSocketFactory that delegates calls. Sockets created by the delegate are wrapped with ones
 * that will not accept the [TLS_FALLBACK_SCSV] cipher, thus bypassing server-side fallback
 * checks on platforms that support it. Unfortunately this wrapping will disable any
 * reflection-based calls to SSLSocket from Platform.
 */
class FallbackTestClientSocketFactory(
  delegate: SSLSocketFactory,
) : DelegatingSSLSocketFactory(delegate) {