fun enqueueResponse(response: MockResponse) {
    delegate.enqueue(response.wrap())
  }

  override fun shutdown() {
    delegate.close()
  }

  fun setFailFast(failFast: Boolean) {
    delegate.setFailFast(failFast)
  }

  fun setFailFast(failFastResponse: MockResponse?) {
    delegate.setFailFast(failFastResponse?.wrap())
  }

  public open fun clear() {
    responseQueue.clear()
  }

  public override fun close() {
    responseQueue.add(DEAD_LETTER)
  }

  public open fun setFailFast(failFast: Boolean) {
    setFailFast(
      failFastResponse =
        when {
          failFast -> MockResponse(code = HttpURLConnection.HTTP_NOT_FOUND)
          else -> null
        },
    )
  }

  public open fun setFailFast(failFastResponse: MockResponse?) {

    public Optional<Boolean> relaxedChecksums() {
        return returnFirstPresentOrEmpty(MavenOptions::relaxedChecksums);
    }

    @Override
    public Optional<Boolean> failFast() {
        return returnFirstPresentOrEmpty(MavenOptions::failFast);
    }

    @Override
    public Optional<Boolean> failAtEnd() {
        return returnFirstPresentOrEmpty(MavenOptions::failAtEnd);
    }

    @Override

            return Optional.of(Boolean.TRUE);
        }
        return Optional.empty();
    }

    @Override
    public Optional<Boolean> failFast() {
        if (commandLine.hasOption(CLIManager.FAIL_FAST)) {
            return Optional.of(Boolean.TRUE);
        }
        return Optional.empty();
    }

    @Override
    public Optional<Boolean> failAtEnd() {

     *
     * @return an {@link Optional} containing true if Maven should stop at the first failure, false if not, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> failFast();

    /**
     * Indicates whether Maven should run all builds but defer error reporting to the end.
     *

        } else {
            return Files.isRegularFile(current) ? current : null;
        }
    }

    protected String determineReactorFailureBehaviour(MavenContext context) {
        if (context.options().failFast().isPresent()) {
            return MavenExecutionRequest.REACTOR_FAIL_FAST;
        } else if (context.options().failAtEnd().isPresent()) {
            return MavenExecutionRequest.REACTOR_FAIL_AT_END;

    @Deprecated
    public static final String ALTERNATE_GLOBAL_TOOLCHAINS = "gt";

    public static final String ALTERNATE_INSTALLATION_TOOLCHAINS = "it";

    public static final String FAIL_FAST = "ff";

    public static final String FAIL_ON_SEVERITY = "fos";

    public static final String FAIL_AT_END = "fae";

    public static final String FAIL_NEVER = "fn";

         * based on the reactor failure behavior.
         * <p>
         * This method works in conjunction with the filtering in executePlan():
         * - For FAIL_FAST: Sets ReactorBuildStatus to halted, which causes executePlan to only process after:* steps
         * - For FAIL_AT_END: Blacklists the project and its dependents, which causes executePlan to skip them

        } else {
            return executionListener;
        }
    }

    private String determineReactorFailureBehaviour(final CommandLine commandLine) {
        if (commandLine.hasOption(CLIManager.FAIL_FAST)) {
            return MavenExecutionRequest.REACTOR_FAIL_FAST;
        } else if (commandLine.hasOption(CLIManager.FAIL_AT_END)) {
            return MavenExecutionRequest.REACTOR_FAIL_AT_END;