var shouldClose: Boolean = false
    var lastSocket: Socket? = null

    override fun connectionAcquired(
      call: Call,
      connection: Connection,
    ) {
      lastSocket = connection.socket()
    }

    override fun requestHeadersStart(call: Call) {
      if (shouldClose) {
        lastSocket!!.close()
      }
    }
  }

  @Test
  fun socketFailureOnLargeRequestHeaders() {

    }
  }

  override fun connectStart(
    route: Route,
    call: Call,
  ) = logEvent(ConnectionEvent.ConnectStart(System.nanoTime(), route, call))

  override fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) = logEvent(
    ConnectionEvent.ConnectFailed(System.nanoTime(), route, call, failure),
  )

  override fun connectEnd(
    connection: Connection,

L1::: Copyright 2012 The Go Authors. All rights reserved.
L2::: Use of this source code is governed by a BSD-style
L3::: license that can be found in the LICENSE file.
L4:
L5:@echo off
L6:
L7:setlocal
L8:
L9:if not exist make.bat (
L10:    echo all.bat must be run from go\src
L11:    exit /b 1
L12:)
L13:
L14:call .\make.bat --no-banner || exit /b 1
L15:call .\run.bat --no-rebuild || exit /b 1
L16:..\bin\go tool dist banner
...

    val client =
      OkHttpClient
        .Builder()
        .connectionPool(poolApi)
        .build()
    val call = client.newCall(Request(addressA.url)) as RealCall
    call.enterNetworkInterceptorExchange(call.request(), true, factory.newChain(call))
    c1.withLock { call.acquireConnectionNoEvents(c1) }

    // Running at time 50, the pool returns that nothing can be evicted until time 150.

            .build()

        val exchange = call.interceptorScopedExchange
        val followUp = followUpRequest(response, exchange)

        if (followUp == null) {
          if (exchange != null && exchange.isDuplex) {
            call.timeoutEarlyExit()
          }
          closeActiveExchange = false
          call.eventListener.followUpDecision(call, response, null)
          return response
        }

	return c.call(ctx, lockRPCRUnlock, &args)
}

// Refresh calls Refresh REST API.
func (c *lockRESTClient) Refresh(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRefresh, &args)
}

// Unlock calls write unlock RPC.
func (c *lockRESTClient) Unlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCUnlock, &args)
}

## [Calls](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-call/)

    override val call: Call,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class CallFailed(
    override val timestampNs: Long,
    override val call: Call,
    val ioe: IOException,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class Canceled(

  public void testReturning() throws Exception {
    assertThat(Callables.returning(null).call()).isNull();

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertSame(value, callable.call());
    // Expect the same value on subsequent calls
    assertSame(value, callable.call());
  }

  @J2ktIncompatible
  @GwtIncompatible

    public int[] batchInsert(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchInsert(list, call, null);
    }

    public int[] batchInsert(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call,
            RequestOptionCall<IndexRequestBuilder> entityCall) {
        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<BadWord> list) {