executor.execute(
          new Runnable() {
            @Override
            public void run() {
              future.set("success");
              if (!future.isDone()) {
                errorMessage.set("Set call exited before future was complete.");
              }
            }
          });
      executor.execute(
          new Runnable() {
            @Override

        }
    }

    public void test_exceptionThrownWithCause() {
        // Test that the exception with cause can be thrown and caught properly
        String expectedMessage = "Command failed to execute";
        Throwable expectedCause = new IllegalStateException("Invalid command state");

        try {
            throw new CommandExecutionException(expectedMessage, expectedCause);

        .header("User-Agent", "OkHttp Headers.java")
        .addHeader("Accept", "application/json; q=0.5")
        .addHeader("Accept", "application/vnd.github.v3+json")
        .build()

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

      println("Server: ${response.header("Server")}")
      println("Date: ${response.header("Date")}")

 * #wrapTask(Callable) wrap} tasks before they are submitted to the underlying executor.
 *
 * <p>Note that task wrapping may occur even if the task is never executed.
 *
 * @author Luke Sandberg
 */
@J2ktIncompatible
@GwtIncompatible
abstract class WrappingScheduledExecutorService extends WrappingExecutorService
    implements ScheduledExecutorService {

     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    Optional<Boolean> yes();

    /**
     * Returns the list of encryption goals to be executed.
     * These goals can include operations like "init", "add-server", "delete-server", etc.
     *
     * @return an {@link Optional} containing the list of goals, or empty if not specified
     */
    @Nonnull

    /**
     * Retrieve toolchain of specified type from build context. It is expected that
     * <code>maven-toolchains-plugin</code> contains the configuration to select the appropriate
     * toolchain and is executed at the beginning of the build.
     *
     * @param type the type, must not be {@code null}
     * @param context the Maven session, must not be {@code null}

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build()

    client.newCall(request).execute().use { response ->
      println("Response completed: $response")
    }
  }
}

fun main() {
  ConfigureTimeouts().run()

        super("stopwords.*\\.txt");
    }

    /**
     * Registers this creator with the dictionary manager upon initialization.
     * This method is annotated with {@link PostConstruct} to be executed after
     * dependency injection is complete.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {
            logger.info("Load {}", this.getClass().getSimpleName());

        .build();
    Request request = new Request.Builder()
        .url("https://en.wikipedia.org/w/index.php")
        .post(formBody)
        .build();

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

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

import org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle;

/**
 * Interface that can be provided by the plugin to wire in custom lifecycles
 * leveraged using the {@link org.apache.maven.api.plugin.annotations.Execute}
 * annotation.  If a {@code META-INF/maven/lifecycle.xml} file is packaged
 * in the plugin, Maven will provide a default implementation that will parse
 * the file and return the contained lifecycle definitions.
 *