class CancelCall {
  private val executor = Executors.newScheduledThreadPool(1)
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build()

    val startNanos = System.nanoTime()
    val call = client.newCall(request)

    // Schedule a job to cancel the call in 1 second.

        "k3": Item(aliased_name="baz", price=2.0, owner_ids=[1, 2, 3]),
    }


client = TestClient(app)


def test_valid():
    response = client.get("/items/valid")
    response.raise_for_status()
    assert response.json() == {"aliased_name": "valid", "price": 1.0, "owner_ids": None}


def test_coerce():
    response = client.get("/items/coerce")
    response.raise_for_status()
    assert response.json() == {

        ]
    }


def test_no_duplicates():
    response = client.post(
        "/no-duplicates",
        json={"item": {"data": "myitem"}, "item2": {"data": "myitem2"}},
    )
    assert response.status_code == 200, response.text
    assert response.json() == [{"data": "myitem"}, {"data": "myitem2"}]


def test_duplicates():
    response = client.post("/with-duplicates", json={"data": "myitem"})

          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
    }

    val client = clientBuilder.build()

    val request =
      Request
        .Builder()
        .url("https://valid-isrgrootx1.letsencrypt.org/robots.txt")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(404)

    val response1 = client.newCall(request1).execute()
    assertThat(response1.code).isEqualTo(401)
    assertThat(response1.body.string())
      .isEqualTo("{\"error\":{\"message\":\"No auth credentials found\",\"code\":401}}")

    val request2 = request1.newBuilder().header("Authorization", "XYZ").build()
    val response2 = client.newCall(request2).execute()
    processResponse(response2, listener)

- **Route Search** - Search by path, method, or name with <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd> (on macOS: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd>).
- **CodeLens Navigation** - Clickable links above test client calls (e.g. `client.get('/items')`) that jump to the matching *path operation* for quick navigation between tests and implementation.
- **Deploy to FastAPI Cloud** - One-click deployment of your app to [FastAPI Cloud](https://fastapicloud.com/).

    server.start();

    OkHttpClient client = new OkHttpClient.Builder()
        .socketFactory(new UnixDomainSocketFactory(socketFile))
        .protocols(Collections.singletonList(Protocol.H2_PRIOR_KNOWLEDGE))
        .build();

    Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {

  val listener = SocketClosingEventListener()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListener(listener)
      .build()

  class SocketClosingEventListener : EventListener() {
    var shouldClose: Boolean = false

  val sslDebug: Boolean by option("--sslDebug").help("Output SSL Debug").flag()

  val url: String? by argument(name = "url").help("Remote resource URL")

  var client: Call.Factory? = null

  override fun run() {
    LoggingUtil.configureLogging(debug = verbose, showHttp2Frames = showHttp2Frames, sslDebug = sslDebug)

    commonRun()
  }

    }

    @Test
    @DisplayName("getNameServiceClient should return initialized name service client")
    void testGetNameServiceClient() {
        // When
        NameServiceClient nameServiceClient = context.getNameServiceClient();

        // Then
        assertNotNull(nameServiceClient, "Name service client should not be null");