assertFalse(options.plugins().isPresent(), "--plugins should not be present by default");
        assertFalse(options.all().isPresent(), "--all should not be present by default");
        assertFalse(options.infer().isPresent(), "--infer should not be present by default");
        assertFalse(options.model().isPresent(), "--fix-model should not be present by default");

			t.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 {

        Optional<BuildResumptionData> result = analyzer.determineBuildResumptionData(executionResult);

        assertTrue(result.isPresent(), "Expected " + result + ".isPresent() to return true");
        assertEquals(asList("test:B"), result.get().getRemainingProjects());
    }

    @Test
    void resumeFromIsIgnoredWhenFirstProjectFails() {

		}
		return ParseSecretKey(s)
	}
}

// IsPresent reports whether a KMS configuration is present.
// It returns an error if multiple KMS configurations are
// present or if one configuration is incomplete.
func IsPresent() (bool, error) {
	// isPresent reports whether at least one of the
	// given env. variables is present.
	isPresent := func(vars ...string) bool {
		for _, v := range vars {

        if (context.options().failFast().isPresent()) {
            return MavenExecutionRequest.REACTOR_FAIL_FAST;
        } else if (context.options().failAtEnd().isPresent()) {
            return MavenExecutionRequest.REACTOR_FAIL_AT_END;
        } else if (context.options().failNever().isPresent()) {
            return MavenExecutionRequest.REACTOR_FAIL_NEVER;
        } else {

                Optional<MavenProject> optSelectedProject =
                        findOptionalProjectBySelector(projects, baseDirectory, selector);
                if (optSelectedProject.isPresent()) {
                    resolvedOptionalProjects.add(optSelectedProject.get());
                    if (activation.activationSettings().recurse()) {

                        .userHome(Path.of(System.getProperty("userHome")))
                        .build());

        Assertions.assertTrue(invokerRequest.options().isPresent());
        Options options = invokerRequest.options().orElseThrow();
        Assertions.assertFalse(options.showVersion().orElse(false));
        Assertions.assertFalse(options.showVersionAndExit().orElse(false));

        return !((java.util.Optional<?>) value).isPresent();
      } else if (value instanceof OptionalInt) {
        return !((OptionalInt) value).isPresent();
      } else if (value instanceof OptionalLong) {
        return !((OptionalLong) value).isPresent();
      } else if (value instanceof OptionalDouble) {
        return !((OptionalDouble) value).isPresent();
      } else if (value instanceof Optional) {

    }

    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) {

    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);