protected long makeKey(Request request) throws IOException {
            return nextKey++;
        }

        @Override
        protected Long peekKey() throws IOException {
            if (recvException != null) {
                throw recvException;
            }
            return peekedKey;
        }

        @Override
        protected void doSend(Request request) throws IOException {

OkHttp Coroutines
=================

Support for Kotlin clients using coroutines.

```kotlin
val call = client.newCall(request)

call.executeAsync().use { response ->
  withContext(Dispatchers.IO) {
    println(response.body?.string())
  }
}
```

This is implemented using `suspendCancellableCoroutine`
but uses the standard Dispatcher in OkHttp. This means
that by default Kotlin's Dispatchers are not used.

        when(ctx.getTransportPool()).thenReturn(testPool);

        // Create an existing connection
        SmbTransportImpl first = testPool.getSmbTransport(ctx, address, 445, false);

        // When: Request another connection
        // Note: Real SmbTransportImpl will report as disconnected without actual socket
        SmbTransportImpl second = testPool.getSmbTransport(ctx, address, 445, false);

## Community Contribution License
All community contributions in this pull request are licensed to the project maintainers
under the terms of the [Apache 2 license](https://www.apache.org/licenses/LICENSE-2.0). 
By creating this pull request I represent that I have the right to license the 
contributions to the project maintainers under the Apache 2 license.

## Description


## Motivation and Context


## How to test this PR?

    logWithTime("requestHeadersStart")

    delegate.requestHeadersStart(call)
  }

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

    delegate.requestHeadersEnd(call, request)
  }

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

    delegate.requestBodyStart(call)
  }

                ComponentUtil.getKeyMatchHelper().update();
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }
        }).orElse(() -> {

pkg net/http, method (*Request) CookiesNamed(string) []*Cookie #61472
pkg net/http, type Cookie struct, Partitioned bool #62490
pkg net/http, type Cookie struct, Quoted bool #46443
pkg net/http, type Request struct, Pattern string #66405
pkg net/http/httptest, func NewRequestWithContext(context.Context, string, string, io.Reader) *http.Request #59473
pkg os, func CopyFS(string, fs.FS) error #62484

import jcifs.internal.smb2.ServerMessageBlock2;
import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Tree Connect request message.
 *
 * This command is used to connect to a shared resource
 * on the server, such as a file share or printer.
 *
 * @author mbechler
 */

  "IMPLICIT_NOTHING_AS_TYPE_PARAMETER",
)
class KotlinSourceModernTest {
  @Test @Ignore
  fun dispatcherFromMockWebServer() {
    val dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse = TODO()

        override fun peek(): MockResponse = TODO()

        override fun shutdown() = TODO()
      }
  }

  @Test @Ignore
  fun mockResponse() {

internal fun addHeaderLenient(
  builder: Headers.Builder,
  name: String,
  value: String,
): Headers.Builder = builder.addLenient(name, value)

internal fun cacheGet(
  cache: Cache,
  request: Request,
): Response? = cache.get(request)

internal fun applyConnectionSpec(
  connectionSpec: ConnectionSpec,
  sslSocket: SSLSocket,
  isFallback: Boolean,
) = connectionSpec.apply(sslSocket, isFallback)