client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .post(AsyncRequestBody())
          .build(),
      )
    assertFailsWith<ProtocolException> {
      call.execute()
    }
  }

  @Test
  fun trueDuplexClientWritesFirst() {
    enableProtocol(Protocol.HTTP_2)
    val body =
      MockSocketHandler()
        .receiveRequest("request A\n")

```

your program could execute like this:

```mermaid
sequenceDiagram

participant code as Code
participant function as say_hi()
participant execute as Execute function

    rect rgba(0, 255, 0, .1)
        code ->> function: say_hi(name="Camila")
        function ->> execute: execute function code
        execute ->> code: return the result
    end

        final String message = "Parameter order test";
        final Exception cause = new RuntimeException("Test cause");

        // Execute with three parameters
        final InvalidQueryException exception3Params = new InvalidQueryException(messageCode, message, cause);

        // Execute with two parameters
        final InvalidQueryException exception2Params = new InvalidQueryException(messageCode, message);

      assertThat(task).isInstanceOf(WrappedRunnable.class);
      return inline.submit(task, result);
    }

    @Override
    public void execute(Runnable command) {
      lastMethodCalled = "execute";
      assertThat(command).isInstanceOf(WrappedRunnable.class);
      inline.execute(command);
    }

    private static <T> void assertTaskWrapped(Collection<? extends Callable<T>> tasks) {

    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))
    val responseA = client.newCall(request).execute()
    assertThat(responseA.body.string()).isEqualTo("a")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    val responseB = client.newCall(request).execute()
    assertThat(responseB.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(1)

        final String originalPath = "/original/path";
        final String customPath = "/api/v1/search";
        mockRequest.setServletPath(originalPath);
        mockRequest.setQueryString("SAStruts.method=execute&query=test");
        webApiRequest = new WebApiRequest(mockRequest, customPath);

        assertEquals(originalPath, webApiRequest.getServletPath());
    }

        final Exception cause = new RuntimeException("Test cause");
        final VaMessenger<FessMessages> messageCode = messages -> messages.addErrorsSsoLoginError(UserMessages.GLOBAL_PROPERTY_KEY);

        // Execute
        final SsoMessageException exception = new SsoMessageException(messageCode, message, cause);

        // Verify
        assertNotNull(exception);
        assertEquals(message, exception.getMessage());

    server.enqueue(MockResponse(body = "def"))

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

    val call = client.newCall(request)
    val response1 = call.execute()

    val cloned = call.clone()
    val response2 = cloned.execute()

    assertThat("abc").isEqualTo(response1.body.string())
    assertThat("def").isEqualTo(response2.body.string())
  }

  @Test
  @Flaky
  fun testMockWebserverRequest() {

 * those implied by the returned execution delay.
 *
 * Cancellation
 * ------------
 *
 * Tasks may be canceled while they are waiting to be executed, or while they are executing.
 *
 * Canceling a task that is waiting to execute prevents that upcoming execution. Canceling a task
 * that is currently executing does not impact the ongoing run, but it does prevent a recurrence
 * from being scheduled.
 *

import org.codelibs.fess.app.web.api.admin.FessApiAdminAction;
import org.codelibs.fess.helper.ProcessHelper;
import org.codelibs.fess.opensearch.config.exentity.FailureUrl;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;

import jakarta.annotation.Resource;

/**
 * API action for admin failure URL.
 *
 */
public class ApiAdminFailureurlAction extends FessApiAdminAction {