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

        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 {

    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"

    }

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

        if (planStep.isPresent() && planStep.get().status.get() == BuildStep.PLANNING) {
            writer.accept("Build plan will be lazily computed");
        } else {
            plan.steps(project)
                    .filter(step ->
                            step.phase != null && step.executions().findAny().isPresent())

        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())
    }

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

        if (context.options().help().isPresent()) {
            Consumer<String> writer = determineWriter(context);
            context.options().displayHelp(context.invokerRequest.parserRequest(), writer);
            throw new InvokerException.ExitException(0);
        }
        if (context.options().showVersionAndExit().isPresent()) {
            showVersion(context);