}
            });
            CommonPoolUtil.execute(() -> {
                try {
                    CloseableUtil.closeQuietly(p.getErrorStream());
                } catch (final Exception e) {
                    logger.warn("Could not close a process error stream.", e);
                }
            });
            CommonPoolUtil.execute(() -> {
                try {

	req.Header.Set("Content-Type", contentTypeHdr)
	req.Header.Set("User-Agent", "Mozilla")

	// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.
	// Call the ServeHTTP to execute the handler.
	apiRouter.ServeHTTP(rec, req)

	ctx, cancel := context.WithCancel(GlobalContext)
	defer cancel()

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

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {

  @After
  fun tearDown() {
    engine.shutdown()
    cacheDir.deleteRecursively()
  }

  @Test
  fun get() {
    val executor = Executors.newCachedThreadPool()

    val completableFuture = execute(engine, executor, "https://google.com/robots.txt")

    try {
      val response = completableFuture.get(10, TimeUnit.SECONDS)

      assertEquals(200, response.code)

import org.apache.maven.api.annotations.ThreadSafe;

/**
 * This interface forms the contract required for Mojos to interact with the Maven infrastructure.
 * It features an {@link #execute()} method, which triggers the Mojo's build-process behavior,
 * and can throw a {@link MojoException} if error conditions occur.
 *
 * @since 4.0.0
 */
@Experimental
@FunctionalInterface
@Consumer
@ThreadSafe

     *            SQL文字列。{@literal null}や空文字列であってはいけません
     * @return 実行した結果
     * @see Statement#execute(String)
     */
    public static boolean execute(final Statement statement, final String sql) {
        assertArgumentNotNull("statement", statement);
        assertArgumentNotEmpty("sql", sql);

        try {
            return statement.execute(sql);
        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);

    @Resource
    protected SearchEngineClient searchEngineClient;

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

    // POST /api/admin/documents/bulk
    @Execute
    public JsonResponse<ApiResult> post$bulk(final BulkBody body) {
        validateApi(body, messages -> {});
        if (body.documents == null) {

    Listener(Runnable command, Executor executor) {
      this.command = checkNotNull(command);
      this.executor = checkNotNull(executor);
    }

    void execute() {
      try {
        executor.execute(command);
      } catch (RuntimeException e) {
        log.log(
            Level.SEVERE,
            "RuntimeException while executing runnable " + command + " with executor " + executor,

      .build()

  fun run() {
    val request =
      Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

        println("Response 1 response:          $it")
        println("Response 1 cache response:    ${it.cacheResponse}")

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

  @ParameterizedTest
  @ArgumentsSource(CancelModelParamProvider::class)