override fun peek(): MockResponse = throw UnsupportedOperationException("unexpected call")

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueue(response.wrap())
  }

  override fun shutdown() {
    delegate.close()
  }

  fun setFailFast(failFast: Boolean) {
    delegate.setFailFast(failFast)
  }

import okio.IOException

suspend fun Call.executeAsync(): Response =
  suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      this.cancel()
    }
    this.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          continuation.resumeWithException(e)
        }

        override fun onResponse(

          }.addNetworkInterceptor { chain ->
            assertThat(isDefaultValue(chain.value())).isFalse()
            chain.proceed(chain.request())
          }.build()

      server.enqueue(
        MockResponse(),
      )
      val response = client.newCall(Request(server.url("/"))).execute()
      response.close()
    }
  }

  /**

  private val client = OkHttpClient()

  @Test
  fun passingTest() {
    assertThat("hello").isEqualTo("hello")
  }

  @Test
  fun testMockWebServer() {
    server.enqueue(MockResponse(body = "abc"))
    server.start()

    client.newCall(Request(url = server.url("/"))).execute().use {
      assertThat(it.body.string()).isEqualTo("abc")
    }
  }

  @Test

/**
 * Unit test for simple App.
 */
public class AppTest {
  private final MockWebServer mockWebServer = new MockWebServer();

  @Test
  public void testApp() throws IOException {
    mockWebServer.enqueue(new MockResponse(200, Headers.of(), "Hello, Maven!"));
    mockWebServer.start();

    new SampleHttpClient().makeCall(mockWebServer.url("/"));
  }

        .heldCertificate(localhostCertificate)
        .build();
    MockWebServer server = new MockWebServer();
    server.useHttps(serverCertificates.sslSocketFactory(), false);
    server.enqueue(new MockResponse());

    HandshakeCertificates clientCertificates = new HandshakeCertificates.Builder()
        .addTrustedCertificate(localhostCertificate.certificate())
        .build();

    OkHttpCaller.callOkHttp(HttpUrl.get("https://square.com/robots.txt"));
  }

  @Test
  public void testMockWebServer() throws IOException {
    MockWebServer server = new MockWebServer();
    server.enqueue(new MockResponse(200, Headers.of(), "Hello, Java9!"));
    server.start();

    // Just check we can run code that depends on OkHttp types
    Call call = OkHttpCaller.callOkHttp(server.url("/"));

  @StartStop
  private val server = MockWebServer()

  @BeforeEach fun setUp() {
    client.start()
  }

  @AfterEach fun tearDown() {
    client.stop()
  }

  @Test fun get() {
    server.enqueue(MockResponse(body = "hello, Jetty HTTP Client"))

    val request =
      client
        .newRequest(server.url("/").toUri())
        .header("Accept", "text/plain")
    val response = request.send()

 */
class OkHttpClientTest {
  @JvmField @RegisterExtension
  val platform = PlatformRule()

  @StartStop
  private val server = MockWebServer()

  @Test fun get() {
    server.enqueue(MockResponse(body = "hello, OkHttp"))

    val client = OkHttpClient()

    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .header("Accept", "text/plain")
        .build()

  }

  private fun newVirtualThreadPerTaskExecutor(): ExecutorService =
    Executors::class.java.getMethod("newVirtualThreadPerTaskExecutor").invoke(null) as ExecutorService

  @Test
  fun testRequest() {
    server.enqueue(MockResponse())

    val request = Request(server.url("/"))

    client.newCall(request).execute().use {
      assertThat(it.code).isEqualTo(200)
    }
  }

  @Test
  fun testIfSupported() {