when:
        Try.successful(value).ifSuccessfulOrElse({ successInvoked = true; assert it == value }, { assert false })
        then:
        successInvoked
    }

    def "failed or else processes failure"() {
        def failure = new RuntimeException("failure")
        boolean failureInvoked = false
        when:

    /**
     * Calls {successConsumer} with the result if the represented operation was successful,
     * otherwise calls {failureConsumer} with the failure.
     */
    public abstract void ifSuccessfulOrElse(Consumer<? super T> successConsumer, Consumer<? super Throwable> failureConsumer);

    private static final class Success<T> extends Try<T> {
        private final T value;

        public Success(T value) {

        request.withValidationContext(context.getValidationContext());
        Result result = request.execute();
        result.getExecution().ifSuccessfulOrElse(
            success -> state.setOutcome(convertOutcome(success.getOutcome())),
            failure -> state.setOutcome(new TaskExecutionException(task, failure))
        );
        return new TaskExecuterResult() {

        }

        @Override
        public void visit(ArtifactVisitor visitor) {
            Try<TransformStepSubject> transformedSubject = finalizeValue();
            transformedSubject.ifSuccessfulOrElse(
                subject -> {
                    for (File output : subject.getFiles()) {
                        ResolvableArtifact resolvedArtifact = artifact.transformedTo(output);

                cacheableWork.getDisplayName(), cacheKey.getHashCode());
        }
        AfterExecutionResult result = executeWithoutCache(cacheableWork.work, context);
        try {
            result.getExecution().ifSuccessfulOrElse(
                executionResult -> storeInCacheUnlessDisabled(cacheableWork, cacheKey, result, executionResult),