/**
     * Returns the Maven command to be executed. This command is used in some invokers (ie forked) but also to
     * present help to user.
     *
     * @return the command string
     */
    @Nonnull
    String command();

    /**
     * Returns the Maven command name (ie "Maven"). This string is used in some invokers to complete error messages.
     *
     * @return the command (human) name
     */

 *
 * <p>The Invoker is designed to be flexible, allowing for different implementations
 * that can handle various types of {@link InvokerRequest InvokerRequests}. It also implements
 * {@link AutoCloseable} to ensure proper resource management.</p>
 *
 * @since 4.0.0
 */
@Experimental
public interface Invoker extends AutoCloseable {
    /**

        super(message, cause);
    }

    /**
     * Exception for intentional exit: No message or anything will be displayed, just the
     * carried exit code will be returned from invoker {@link Invoker#invoke(InvokerRequest)} method.
     */
    public static final class ExitException extends InvokerException {
        private final int exitCode;

        public ExitException(int exitCode) {

        return null;
    }

    /**
     * Assists client invoke names for DBFlute behavior invocation.
     *
     * @return array of default client invoke names
     */
    @Override
    public String[] assistClientInvokeNames() {
        return DEFAULT_CLIENT_INVOKE_NAMES;
    }

    /**
     * Assists bypass invoke names for DBFlute behavior invocation.
     *

     * @see Method#invoke(Object, Object[])
     */
    @SuppressWarnings("unchecked")
    public static <T> T invoke(final Method method, final Object target, final Object... args)
            throws InvocationTargetRuntimeException, IllegalAccessRuntimeException {
        assertArgumentNotNull("method", method);

        try {
            return (T) method.invoke(target, args);

 * @since 10.0
 */
@GwtCompatible
public final class Uninterruptibles {

  // Implementation Note: As of 3-7-11, the logic for each blocking/timeout
  // methods is identical, save for method being invoked.

  /** Invokes {@code latch.}{@link CountDownLatch#await() await()} uninterruptibly. */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  public static void awaitUninterruptibly(CountDownLatch latch) {

        public String toString() {
          throw new AssertionFailedError();
        }
      };

  private static class Message {
    boolean invoked;

    @Override
    public String toString() {
      assertFalse(invoked);
      invoked = true;
      return "A message";
    }
  }

  private static final String FORMAT = "I ate %s pies.";

        public String toString() {
          throw new AssertionFailedError();
        }
      };

  private static class Message {
    boolean invoked;

    @Override
    public String toString() {
      assertFalse(invoked);
      invoked = true;
      return "A message";
    }
  }

  private static final String FORMAT = "I ate %s pies.";

    /**
     * Invokes the method and returns its result.
     *
     * @param <T>
     *            the return type of the method
     * @param target
     *            the target object. Must not be {@literal null}
     * @param args
     *            the method arguments
     * @return the result of the method
     */
    <T> T invoke(Object target, Object... args);

    /**

   * <p>This method should return promptly; prefer to do work on a different thread where it is
   * convenient. It is invoked exactly once on service shutdown, even when {@link #stopAsync} is
   * called multiple times.
   *
   * <p>If {@link #stopAsync} is called on a {@link State#STARTING} service, this method is not
   * invoked immediately. Instead, it will be deferred until after the service is {@link