delegate!!.removeHandshakeCompletedListener(listener)
  }

  @Throws(IOException::class)
  override fun startHandshake() {
    delegate!!.startHandshake()
  }

  override fun setUseClientMode(mode: Boolean) {
    delegate!!.useClientMode = mode
  }

  override fun getUseClientMode(): Boolean {
    return delegate!!.useClientMode
  }

  override fun setNeedClientAuth(need: Boolean) {

    return delegate!!.lastAccessedTime
  }

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

  override fun isValid(): Boolean {
    return delegate!!.isValid
  }

  override fun putValue(
    s: String,
    o: Any,
  ) {
    delegate!!.putValue(s, o)
  }

  override fun getValue(s: String): Any {
    return delegate!!.getValue(s)
  }

      before() // This implicitly starts the delegate.
      return delegate.port
    }

  val hostName: String
    get() {
      before() // This implicitly starts the delegate.
      return delegate.hostName
    }

  var protocolNegotiationEnabled: Boolean by delegate::protocolNegotiationEnabled

  @get:JvmName("protocols")
  var protocols: List<Protocol>
    get() = delegate.protocols
    set(value) {

    return delegate.defaultCipherSuites
  }

  override fun getSupportedCipherSuites(): Array<String> {
    return delegate.supportedCipherSuites
  }

  @Throws(IOException::class)
  override fun createSocket(
    socket: Socket,
    host: String,
    port: Int,
    autoClose: Boolean,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(socket, host, port, autoClose) as SSLSocket

    delegate.connectStart(call, inetSocketAddress, proxy)
  }

  override fun secureConnectStart(call: Call) {
    logWithTime("secureConnectStart")

    delegate.secureConnectStart(call)
  }

  override fun secureConnectEnd(
    call: Call,
    handshake: Handshake?,
  ) {
    logWithTime("secureConnectEnd: $handshake")

    delegate.secureConnectEnd(call, handshake)
  }

 */
public class CIFSContextWrapper implements CIFSContext {

    private final CIFSContext delegate;
    private Handler wrappedHandler;


    /**
     * @param delegate
     *            context to delegate non-override methods to
     * 
     */
    public CIFSContextWrapper ( CIFSContext delegate ) {
        this.delegate = delegate;
    }


    /**
     * {@inheritDoc}
     * 
     * @throws CIFSException

    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 Deque<E> delegate = Lists.newLinkedList();
    public 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

    return delegate().get(index);
  }

  @Override
  public int indexOf(@CheckForNull Object element) {
    return delegate().indexOf(element);
  }

  @Override
  public int lastIndexOf(@CheckForNull Object element) {
    return delegate().lastIndexOf(element);
  }

  @Override
  public ListIterator<E> listIterator() {
    return delegate().listIterator();
  }

  @Override

        Thread.sleep(500); // to make sure queue is processed, cancellation applied

        Mockito.verify(delegate).transferInitiated(transferInitiatedEvent);
        Mockito.verify(delegate).transferStarted(transferStartedEvent);
        Mockito.verify(delegate).transferProgressed(transferProgressedEvent);
        Mockito.verify(delegate).transferSucceeded(transferSucceededEvent);
    }

    private static TransferEvent event(