override fun toString(): String = delegate!!.toString()

  override fun getLocalSocketAddress(): SocketAddress = delegate!!.localSocketAddress

  override fun getRemoteSocketAddress(): SocketAddress = delegate!!.remoteSocketAddress

  override fun isBound(): Boolean = delegate!!.isBound

  override fun isConnected(): Boolean = delegate!!.isConnected

  override fun isClosed(): Boolean = delegate!!.isClosed

  }

  override fun connectionReleased(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionReleased")
  }

  override fun requestHeadersStart(call: Call) {
    logWithTime("requestHeadersStart")
  }

  override fun requestHeadersEnd(
    call: Call,
    request: Request,
  ) {
    logWithTime("requestHeadersEnd")
  }

  }

  @Override
  public Iterator<E> iterator() {
    return delegate.iterator();
  }

  @Override
  public E last() {
    return delegate.last();
  }

  @Override
  public @Nullable E lower(E e) {
    return delegate.lower(checkValid(e));
  }

  @Override
  public @Nullable E pollFirst() {
    return delegate.pollFirst();
  }

  @Override

) : SSLSession {
  override fun getId(): ByteArray = delegate!!.id

  override fun getSessionContext(): SSLSessionContext = delegate!!.sessionContext

  override fun getCreationTime(): Long = delegate!!.creationTime

  override fun getLastAccessedTime(): Long = delegate!!.lastAccessedTime

  override fun invalidate() {
    delegate!!.invalidate()
  }

  override fun isValid(): Boolean = delegate!!.isValid

    }

    @Override public void proxySelectStart(Call call, HttpUrl url) {
      printEvent("proxySelectStart");
    }

    @Override public void proxySelectEnd(Call call, HttpUrl url, List<Proxy> proxies) {
      printEvent("proxySelectEnd");
    }

    @Override public void callStart(Call call) {
      printEvent("callStart");
    }

  /** Constructor for use by subclasses. */
  protected ForwardingCollection() {}

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

  @Override
  public Iterator<E> iterator() {
    return delegate().iterator();
  }

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

  @CanIgnoreReturnValue
  @Override
  public boolean removeAll(Collection<?> collection) {

  /** Constructor for use by subclasses. */
  protected ForwardingCollection() {}

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

  @Override
  public Iterator<E> iterator() {
    return delegate().iterator();
  }

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

  @CanIgnoreReturnValue
  @Override
  public boolean removeAll(Collection<?> collection) {

      this.backingSet = backingSet;
    }

    @Override
    protected NavigableSet<T> delegate() {
      return backingSet;
    }

    @Override
    public boolean equals(@Nullable Object object) {
      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public boolean addAll(Collection<? extends T> collection) {

  /** Constructor for use by subclasses. */
  protected ForwardingTable() {}

  @Override
  protected abstract Table<R, C, V> delegate();

  @Override
  public Set<Cell<R, C, V>> cellSet() {
    return delegate().cellSet();
  }

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

  @Override
  public Map<R, V> column(@ParametricNullness C columnKey) {
    return delegate().column(columnKey);

    super(domain);
  }

  @Override
  public C first() {
    throw new NoSuchElementException();
  }

  @Override
  public C last() {
    throw new NoSuchElementException();
  }

  @Override
  public int size() {
    return 0;
  }

  @Override
  public ContiguousSet<C> intersection(ContiguousSet<C> other) {
    return this;
  }

  @Override
  public Range<C> range() {