return batchInsert(list, call, null);
    }

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

    this.singleRowKey = checkNotNull(rowKey);
    this.singleColumnKey = checkNotNull(columnKey);
    this.singleValue = checkNotNull(value);
  }

  SingletonImmutableTable(Cell<R, C, V> cell) {
    this(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
  }

  @Override
  public ImmutableMap<R, V> column(C columnKey) {
    checkNotNull(columnKey);
    return containsColumn(columnKey)

      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          continuation.resumeWithException(e)
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          continuation.resume(response) { _, value, _ ->
            value.closeQuietly()
          }
        }
      },
    )

        .build()
    val latch = CountDownLatch(1)
    val exceptionRef = AtomicReference<Throwable>()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    call.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          exceptionRef.set(e)
          latch.countDown()
        }

    server.requestClientAuth()
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .build(),
    )
    val call = client.newCall(Request.Builder().url(server.url("/")).build())
    val response = call.execute()
    assertThat(response.handshake!!.peerPrincipal)
      .isEqualTo(X500Principal("CN=Local Host"))
    assertThat(response.handshake!!.localPrincipal)

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

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

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

// Stat captures time taken to call os.Stat
func Stat(name string) (info os.FileInfo, err error) {
	defer updateOSMetrics(osMetricStat, name)(err)
	return os.Stat(name)
}

// Create captures time taken to call os.Create
func Create(name string) (f *os.File, err error) {
	defer updateOSMetrics(osMetricCreate, name)(err)
	return os.Create(name)
}

// Fdatasync captures time taken to call Fdatasync

	if err != nil {
		return nil, toStorageErr(err)
	}
	return respBody, nil
}

// Wrapper to restClient.Call to handle network errors, in case of network error the connection is disconnected
// and a healthcheck routine gets invoked that would reconnect.
func (client *storageRESTClient) call(ctx context.Context, rpcMethod string, values url.Values, body io.Reader, length int64) (io.ReadCloser, error) {
	if values == nil {

An example could be that you have an external authentication provider that you need to call.

You send it a token and it returns an authenticated user.

This provider might be charging you per request, and calling it might take some extra time than if you had a fixed mock user for tests.

You probably want to test the external provider once, but not necessarily call it for every test that runs.

   * [synchronously][Call.execute] and [asynchronously][Call.enqueue].
   */
  @Synchronized
  fun cancelAll() {
    for (call in readyAsyncCalls) {
      call.call.cancel()
    }
    for (call in runningAsyncCalls) {
      call.call.cancel()
    }
    for (call in runningSyncCalls) {
      call.cancel()
    }
  }

  /**