/**
 * Abstract class representing a request that can be executed to produce a response.
 *
 * @param <T> the type of response produced by this request
 */
public abstract class Request<T extends Response> {
    /**
     * Constructs a new request.
     */
    public Request() {
        // nothing
    }

    /**
     * Executes the request.
     * @param client The OpenSearch client.

    assertFalse(task.isCancelled());

    // Start the task to put it in the RUNNING state.  Have to use a separate
    // thread because the task will block on the task latch after unblocking
    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the

        this.client = client;
        this.request = request;
    }

    /**
     * Executes the request.
     * @return A Promise that will be resolved with the response or rejected with an error.
     */
    public Deferred<Res>.Promise execute() {
        return request.execute(client);
    }

          // If the delegate is already done, run the execution list immediately on the current
          // thread.
          executionList.execute();
          return;
        }

        // TODO(lukes): handle RejectedExecutionException
        adapterExecutor.execute(
            () -> {
              try {
                /*
                 * Threads from our private pool are never interrupted. Threads from a

                final BulkResponse bulkResponse = bulkRequest.execute().actionGet(bulkTimeout);
                if (bulkResponse.hasFailures()) {
                    throw new IllegalBehaviorStateException(bulkResponse.buildFailureMessage());
                }

                response = client.prepareSearchScroll(scrollId).setScroll(scrollForDelete).execute().actionGet(scrollSearchTimeout);

        try {
            when(sitemapsHelper.parse(any(InputStream.class))).thenReturn(sitemapSet);
        } catch (Exception e) {
            fail("Should not throw exception in test setup");
        }

        // Execute and verify ChildUrlsException is thrown
        try {
            processor.process(responseData);
            fail("Should throw ChildUrlsException");
        } catch (ChildUrlsException e) {

      MockResponse(body = "unexpected call to IPv4"),
    )
    serverIpv6.enqueue(
      MockResponse(body = "hello from IPv6"),
    )

    val call = client.newCall(Request(url))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("hello from IPv6")

    // In the process we made one successful connection attempt.

    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)

    //                                                                      Search Execute
    //                                                                      ==============

    /**
     * Returns the OSDD document.
     *
     * @return the OSDD document as a stream response
     */
    @Execute
    public ActionResponse index() {
        if (isLoginRequired()) {
            return redirectToLogin();

        .post(sleepingRequestBody(500))
        .build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun timeoutWritingRequestWithEnqueue() {