.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() {

                    .setId(id)
                    .setDocAsUpsert(true)
                    .setDoc(builder)
                    .execute()
                    .actionGet(settings.getIndexTimeout());
            client.admin().indices().prepareRefresh().setIndices(actualIndex).execute().actionGet(settings.getIndicesTimeout());
        } catch (final Exception e) {

     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse index() {
        return asIndexHtml();
    }

    /**
     * Downloads a log file by its encoded ID.
     *
     * @param id the Base64 encoded filename of the log file to download
     * @return ActionResponse containing the log file stream
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })

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

    /**
     * Retrieves the list of available log files.
     *
     * @return JSON response containing log file list
     */
    // GET /api/admin/log/files
    @Execute
    public JsonResponse<ApiResult> files() {

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)

        </field>
        <field>
          <name>executions</name>
          <version>1.0.0+</version>
          <description>The goals to execute within the phase.</description>
          <association>
            <type>Execution</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
        <field>

    //                                                                      Search Execute
    //                                                                      ==============
    /**
     * The index page.
     * @param form The search form.
     * @return The HTML response.
     */
    @Execute
    public HtmlResponse index(final SearchForm form) {
        return search(form);
    }

    /**

import org.codelibs.fess.app.web.api.ApiResult.Status;
import org.codelibs.fess.app.web.api.admin.FessApiAdminAction;
import org.codelibs.fess.opensearch.config.exentity.JobLog;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;

import jakarta.annotation.Resource;

/**
 * API action for admin job log management.

import org.codelibs.fess.app.web.api.ApiResult;
import org.codelibs.fess.app.web.api.admin.FessApiAdminAction;
import org.codelibs.fess.opensearch.config.exentity.PathMapping;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;

import jakarta.annotation.Resource;

/**
 * API action for admin path mapping management.

                }
                fail("Expected connection to be closed")
              }
            },
        ),
      )
    cancelLater(call, 500)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }
  }

  @Test
  fun cancelReadingResponseBody() {
    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.