cmdAndArguments.add("--install-toolchains");
            cmdAndArguments.add(mavenOptions.altInstallationToolchains().get());
        }
        if (mavenOptions.logFile().isPresent()) {
            cmdAndArguments.add("--log-file");
            cmdAndArguments.add(mavenOptions.logFile().get());
        }
        if (mavenOptions.color().isPresent()) {
            cmdAndArguments.add("--color");

    val rcNumber = buildRcNumber
    val milestoneNumber = buildMilestoneNumber

    if (
        (buildFinalRelease.isPresent && buildRcNumber.isPresent) ||
        (buildFinalRelease.isPresent && buildMilestoneNumber.isPresent) ||
        (buildRcNumber.isPresent && buildMilestoneNumber.isPresent)
    ) {
        throw InvalidUserDataException("Cannot set any combination of milestoneNumber, rcNumber and finalRelease at the same time")

			os.Setenv(k, v)
		}

		ok, err := IsPresent()
		if err != nil && !test.ShouldFail {
			t.Fatalf("Test %d: %v", i, err)
		}
		if err == nil && test.ShouldFail {
			t.Fatalf("Test %d: should have failed but succeeded", i)
		}

		if !test.ShouldFail && ok != test.IsPresent {
			t.Fatalf("Test %d: reported that KMS present=%v - want present=%v", i, ok, test.IsPresent)
		}
	}
}

var isPresentTests = []struct {

    }

    protected <T> Optional<T> returnFirstPresentOrEmpty(Function<O, Optional<T>> getter) {
        for (O option : options) {
            Optional<T> o = getter.apply(option);
            if (o.isPresent()) {
                return o;
            }
        }
        return Optional.empty();
    }

    protected Optional<List<String>> collectListIfPresentOrEmpty(Function<O, Optional<List<String>>> getter) {

    private
    val timestampSource: String
        get() = parameters.run {
            when {
                buildTimestampFromBuildReceipt.isPresent -> "from build receipt"
                buildTimestampFromGradleProperty.isPresent -> "from buildTimestamp property"
                runningInstallTask.get() -> "from current time because installing"

    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).isPresent();

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);

        for (String selector : projectSelectors) {
            Optional<MavenProject> optSelectedProject =
                    findOptionalProjectBySelector(projects, baseDirectory, selector);
            if (!optSelectedProject.isPresent()) {
                String message = "Could not find the selected project in the reactor: " + selector;
                throw new MavenExecutionException(message, request.getPom());
            }

        if (!changed(member)) {
            return null
        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {
            // breaking change would be reported
            return null
        }

        return checkSuperClassChanges(member, oldClass.get(), newClass.get())
    }

  @SuppressWarnings("unchecked") // implementation is "fully variant"
  static <T> Optional<T> withType() {
    return (Optional<T>) INSTANCE;
  }

  private Absent() {}

  @Override
  public boolean isPresent() {
    return false;
  }

  @Override
  public T get() {
    throw new IllegalStateException("Optional.get() cannot be called on an absent value");
  }

  @Override
  public T or(T defaultValue) {

@GwtCompatible
@ElementTypesAreNonnullByDefault
final class Present<T> extends Optional<T> {
  private final T reference;

  Present(T reference) {
    this.reference = reference;
  }

  @Override
  public boolean isPresent() {
    return true;
  }

  @Override
  public T get() {
    return reference;
  }

  @Override
  public T or(T defaultValue) {