val results =
        (1..20).map {
          executor.submit {
            val response =
              client.newCall(Request((mockServer.secureEndpoint + "/person?name=peter").toHttpUrl())).execute()

            val body = response.body.string()
            assertThat(body).contains("Peter the person")
          }
        }

      results.forEach {
        it.get()
      }
    }
  }

  }

  /** Simple same thread listening executor service that doesn't handle shutdown. */
  private static class TestListeningExecutorService extends AbstractListeningExecutorService {

    @Override
    public void execute(Runnable runnable) {
      assertThat(runnable).isInstanceOf(TrustedListenableFutureTask.class);
      runnable.run();
    }

    @Override
    public void shutdown() {}

    @Override

        for (int i = 0; i < numTasks; i++) {
            tasks.add(testCallable);
        }

        // Get start time
        final long time = System.nanoTime();

        // Execute callable tasks concurrently
        final ExecutorService executor = Executors.newFixedThreadPool(numTasks);
        try {
            final List<Future<Integer>> futures = executor.invokeAll(tasks);

      Request
        .Builder()
        .header("Authorization", "Client-ID $IMGUR_CLIENT_ID")
        .url("https://api.imgur.com/3/image")
        .post(requestBody)
        .build()

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      println(response.body.string())
    }
  }

  companion object {
    /**

${project.name}

 ${project.description}

* Useful entry points

 * {{{./apidocs/org/apache/maven/cli/MavenCli.html}MavenCli.doMain(CliRequest)}} is the main method preparing runtime environment before running {{{../maven-core/}Maven.execute()}}

* References

 * {{{./cli.html}CLI options}},

 * {{{./logging.html}logging API}}.

 * since 3.3.1 (see {{{/docs/3.3.1/release-notes.html#Core_Extensions}3.3.1 release notes}} for more details),

    #
    #; isSuppressDropDBLink = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o initializeFirstSqlList: (NotRequired - Default list:{})
    #  You can execute the SQL statements before initializing schema.
    #
    #; initializeFirstSqlList = list:{}
    # - - - - - - - - - -/
}

~~ under the License.

 -----
 Maven plugins
 -----
 The Maven Team
 -----

Maven plugin execution isolation

 Maven2 takes advantage of Plexus' ability to execute a component using a
 ClassWorlds ClassRealm that is populated with the JAR containing the
 component in question and all of its dependencies. Using ClassWorlds
 notation for realms we have the following:

+-----+

        .url("https://api.github.com/markdown/raw")
        .post(pipeBody)
        .build();

    streamPrimesToSinkAsynchronously(pipeBody.sink());

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

        .Builder()
        .body("hello, Apache HttpClient 5.x")
        .build(),
    )

    val request = HttpGet(server.url("/").toUri())
    request.addHeader("Accept", "text/plain")

    httpClient.execute(request).use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(EntityUtils.toString(response.entity)).isEqualTo("hello, Apache HttpClient 5.x")
    }

    val recorded = server.takeRequest()

    }, 1, TimeUnit.SECONDS);

    System.out.printf("%.2f Executing call.%n", (System.nanoTime() - startNanos) / 1e9f);
    try (Response response = call.execute()) {
      System.out.printf("%.2f Call was expected to fail, but completed: %s%n",
          (System.nanoTime() - startNanos) / 1e9f, response);
    } catch (IOException e) {